Changeset 6076 in vbox for trunk/src/VBox/Main

Timestamp:

Dec 14, 2007 7:23:03 PM (17 years ago)

Author:

vboxsync

Message:

Merged dmik/s2 branch (r25959:26751) to the trunk.

Location:

trunk/src/VBox/Main

Files:

• AudioAdapterImpl.cpp (modified) (1 diff)
• BIOSSettingsImpl.cpp (modified) (1 diff)
• DVDDriveImpl.cpp (modified) (2 diffs)
• Doxyfile.Main (modified) (1 diff)
• FloppyDriveImpl.cpp (modified) (2 diffs)
• HardDiskImpl.cpp (modified) (21 diffs)
• HostImpl.cpp (modified) (3 diffs)
• MachineDebuggerImpl.cpp (modified) (1 diff)
• MachineImpl.cpp (modified) (84 diffs)
• Makefile.kmk (modified) (14 diffs)
• NetworkAdapterImpl.cpp (modified) (1 diff)
• ParallelPortImpl.cpp (modified) (2 diffs)
• SerialPortImpl.cpp (modified) (3 diffs)
• SnapshotImpl.cpp (modified) (3 diffs)
• SystemPropertiesImpl.cpp (modified) (1 diff)
• USBControllerImpl.cpp (modified) (5 diffs)
• VBoxDll.cpp (modified) (1 diff)
• VirtualBoxBase.cpp (modified) (2 diffs)
• VirtualBoxImpl.cpp (modified) (33 diffs)
• VirtualBoxImplExtra.cpp (added)
• VirtualBoxXMLUtil.cpp (deleted)
• glue/com.cpp (modified) (3 diffs)
• glue/string.cpp (modified) (3 diffs)
• idl/VirtualBox.xidl (modified) (4 diffs)
• include/AudioAdapterImpl.h (modified) (2 diffs)
• include/BIOSSettingsImpl.h (modified) (2 diffs)
• include/DVDDriveImpl.h (modified) (2 diffs)
• include/FloppyDriveImpl.h (modified) (2 diffs)
• include/HardDiskImpl.h (modified) (12 diffs)
• include/HostImpl.h (modified) (3 diffs)
• include/MachineImpl.h (modified) (9 diffs)
• include/NetworkAdapterImpl.h (modified) (2 diffs)
• include/ParallelPortImpl.h (modified) (4 diffs)
• include/SerialPortImpl.h (modified) (4 diffs)
• include/SnapshotImpl.h (modified) (3 diffs)
• include/SystemPropertiesImpl.h (modified) (3 diffs)
• include/USBControllerImpl.h (modified) (3 diffs)
• include/VRDPServerImpl.h (modified) (3 diffs)
• include/VirtualBoxBase.h (modified) (10 diffs)
• include/VirtualBoxImpl.h (modified) (5 diffs)
• include/VirtualBoxXMLUtil.h (modified) (3 diffs)
• xml/Settings.cpp (added)
• xml/VirtualBox-settings-common.xsd (modified) (4 diffs)
• xml/VirtualBox-settings-freebsd.xsd (modified) (1 diff)
• xml/VirtualBox-settings-linux.xsd (modified) (1 diff)
• xml/VirtualBox-settings-macosx.xsd (modified) (1 diff)
• xml/VirtualBox-settings-os2.xsd (modified) (1 diff)
• xml/VirtualBox-settings-solaris.xsd (modified) (1 diff)
• xml/VirtualBox-settings-windows.xsd (modified) (1 diff)

trunk/src/VBox/Main/AudioAdapterImpl.cpp

@@ -272 +272 @@
 
 /** 
+ *  Loads settings from the given machine node.
+ *  May be called once right after this object creation.
+ * 
+ *  @param aMachineNode <Machine> node.
+ * 
+ *  @note Locks this object for writing. 
+ */
+HRESULT AudioAdapter::loadSettings (const settings::Key &aMachineNode)
+{
+    using namespace settings;
+
+    AssertReturn (!aMachineNode.isNull(), E_FAIL);
+
+    AutoCaller autoCaller (this);
+    AssertComRCReturnRC (autoCaller.rc());
+
+    AutoLock alock (this);
+
+    /* Note: we assume that the default values for attributes of optional
+     * nodes are assigned in the Data::Data() constructor and don't do it
+     * here. It implies that this method may only be called after constructing
+     * a new BIOSSettings object while all its data fields are in the default
+     * values. Exceptions are fields whose creation time defaults don't match
+     * values that should be applied when these fields are not explicitly set
+     * in the settings file (for backwards compatibility reasons). This takes
+     * place when a setting of a newly created object must default to A while
+     * the same setting of an object loaded from the old settings file must
+     * default to B. */ 
+
+    /* AudioAdapter node (required) */
+    Key audioAdapterNode = aMachineNode.key ("AudioAdapter");
+
+    /* is the adapter enabled? (required) */
+    mData->mEnabled = audioAdapterNode.value <bool> ("enabled");
+
+    /* now check the audio driver (required) */
+    const char *driver = audioAdapterNode.stringValue ("driver");
+    mData->mAudioDriver = AudioDriverType_NullAudioDriver;
+    if      (strcmp (driver, "null") == 0)
+        ; /* Null has been set above */
+#ifdef RT_OS_WINDOWS
+    else if (strcmp (driver, "winmm") == 0)
+#ifdef VBOX_WITH_WINMM
+        mData->mAudioDriver = AudioDriverType_WINMMAudioDriver;
+#else
+        /* fall back to dsound */
+        mData->mAudioDriver = AudioDriverType_DSOUNDAudioDriver;
+#endif
+    else if (strcmp (driver, "dsound") == 0)
+        mData->mAudioDriver = AudioDriverType_DSOUNDAudioDriver;
+#endif // RT_OS_WINDOWS
+#ifdef RT_OS_LINUX
+    else if (strcmp (driver, "oss") == 0)
+        mData->mAudioDriver = AudioDriverType_OSSAudioDriver;
+    else if (strcmp (driver, "alsa") == 0)
+# ifdef VBOX_WITH_ALSA
+        mData->mAudioDriver = AudioDriverType_ALSAAudioDriver;
+# else
+        /* fall back to OSS */
+        mData->mAudioDriver = AudioDriverType_OSSAudioDriver;
+# endif
+    else if (strcmp (driver, "pulse") == 0)
+# ifdef VBOX_WITH_PULSE
+        mData->mAudioDriver = AudioDriverType_PulseAudioDriver;
+# else
+        /* fall back to OSS */
+        mData->mAudioDriver = AudioDriverType_OSSAudioDriver;
+# endif
+#endif // RT_OS_LINUX
+#ifdef RT_OS_DARWIN
+    else if (strcmp (driver, "coreaudio") == 0)
+        mData->mAudioDriver = AudioDriverType_CoreAudioDriver;
+#endif
+#ifdef RT_OS_OS2
+    else if (strcmp (driver, "mmpm") == 0)
+        mData->mAudioDriver = AudioDriverType_MMPMAudioDriver;
+#endif
+    else
+        AssertMsgFailed (("Invalid driver '%s'\n", driver));
+
+    return S_OK;
+}
+
+/** 
+ *  Saves settings to the given machine node.
+ * 
+ *  @param aMachineNode <Machine> node.
+ * 
+ *  @note Locks this object for reading. 
+ */
+HRESULT AudioAdapter::saveSettings (settings::Key &aMachineNode)
+{
+    using namespace settings;
+
+    AssertReturn (!aMachineNode.isNull(), E_FAIL);
+
+    AutoCaller autoCaller (this);
+    AssertComRCReturnRC (autoCaller.rc());
+
+    AutoReaderLock alock (this);
+
+    Key node = aMachineNode.createKey ("AudioAdapter");
+
+    const char *driverStr = NULL;
+    switch (mData->mAudioDriver)
+    {
+        case AudioDriverType_NullAudioDriver:
+        {
+            driverStr = "null";
+            break;
+        }
+#ifdef RT_OS_WINDOWS
+            case AudioDriverType_WINMMAudioDriver:
+# ifdef VBOX_WITH_WINMM
+            {
+                driverStr = "winmm";
+                break;
+            }
+# endif
+            case AudioDriverType_DSOUNDAudioDriver:
+            {
+                driverStr = "dsound";
+                break;
+            }
+#endif /* RT_OS_WINDOWS */
+#ifdef RT_OS_LINUX
+            case AudioDriverType_ALSAAudioDriver:
+# ifdef VBOX_WITH_ALSA
+            {
+                driverStr = "alsa";
+                break;
+            }
+# endif
+            case AudioDriverType_PulseAudioDriver:
+# ifdef VBOX_WITH_PULSE
+            {
+                driverStr = "pulse";
+                break;
+            }
+# endif
+            case AudioDriverType_OSSAudioDriver:
+            {
+                driverStr = "oss";
+                break;
+            }
+#endif /* RT_OS_LINUX */
+#ifdef RT_OS_DARWIN
+            case AudioDriverType_CoreAudioDriver:
+            {
+                driverStr = "coreaudio";
+                break;
+            }
+#endif
+#ifdef RT_OS_OS2
+            case AudioDriverType_MMPMAudioDriver:
+            {
+                driverStr = "mmpm";
+                break;
+            }
+#endif
+            default:
+                ComAssertMsgFailedRet (("Wrong audio driver type! driver = %d\n",
+                                        mData->mAudioDriver),
+                                       E_FAIL);
+    }
+    node.setStringValue ("driver", driverStr);
+
+    node.setValue <bool> ("enabled", !!mData->mEnabled);
+
+    return S_OK;
+}
+
+/** 
  *  @note Locks this object for writing.
  */

trunk/src/VBox/Main/BIOSSettingsImpl.cpp

@@ -489 +489 @@
 /////////////////////////////////////////////////////////////////////////////
 
+/** 
+ *  Loads settings from the given machine node.
+ *  May be called once right after this object creation.
+ * 
+ *  @param aMachineNode <Machine> node.
+ * 
+ *  @note Locks this object for writing. 
+ */
+HRESULT BIOSSettings::loadSettings (const settings::Key &aMachineNode)
+{
+    using namespace settings;
+
+    AssertReturn (!aMachineNode.isNull(), E_FAIL);
+
+    AutoCaller autoCaller (this);
+    AssertComRCReturnRC (autoCaller.rc());
+
+    AutoLock alock (this);
+
+    /* Note: we assume that the default values for attributes of optional
+     * nodes are assigned in the Data::Data() constructor and don't do it
+     * here. It implies that this method may only be called after constructing
+     * a new BIOSSettings object while all its data fields are in the default
+     * values. Exceptions are fields whose creation time defaults don't match
+     * values that should be applied when these fields are not explicitly set
+     * in the settings file (for backwards compatibility reasons). This takes
+     * place when a setting of a newly created object must default to A while
+     * the same setting of an object loaded from the old settings file must
+     * default to B. */ 
+
+    /* BIOS node (required) */
+    Key biosNode = aMachineNode.key ("BIOS");
+
+    /* ACPI (required) */
+    {
+        Key acpiNode = biosNode.key ("ACPI");
+
+        mData->mACPIEnabled = acpiNode.value <bool> ("enabled");
+    }
+
+    /* IOAPIC (optional) */
+    {
+        Key ioapicNode = biosNode.findKey ("IOAPIC");
+        if (!ioapicNode.isNull())
+            mData->mIOAPICEnabled = ioapicNode.value <bool> ("enabled");
+    }
+
+    /* Logo (optional) */
+    {
+        Key logoNode = biosNode.findKey ("Logo");
+        if (!logoNode.isNull())
+        {
+            mData->mLogoFadeIn = logoNode.value <bool> ("fadeIn");
+            mData->mLogoFadeOut = logoNode.value <bool> ("fadeOut");
+            mData->mLogoDisplayTime = logoNode.value <ULONG> ("displayTime");
+            mData->mLogoImagePath = logoNode.stringValue ("imagePath");
+        }
+    }
+
+    /* boot menu (optional) */
+    {
+        Key bootMenuNode = biosNode.findKey ("BootMenu");
+        if (!bootMenuNode.isNull())
+        {
+            mData->mBootMenuMode = BIOSBootMenuMode_MessageAndMenu;
+            const char *modeStr = bootMenuNode.stringValue ("mode");
+
+            if (strcmp (modeStr, "disabled") == 0)
+                mData->mBootMenuMode = BIOSBootMenuMode_Disabled;
+            else if (strcmp (modeStr, "menuonly") == 0)
+                mData->mBootMenuMode = BIOSBootMenuMode_MenuOnly;
+            else if (strcmp (modeStr, "messageandmenu") == 0)
+                mData->mBootMenuMode = BIOSBootMenuMode_MessageAndMenu;
+            else
+                ComAssertMsgFailedRet (("Invalid boot menu mode '%s'\n", modeStr),
+                                       E_FAIL);
+        }
+    }
+
+    /* PXE debug logging (optional) */
+    {
+        Key pxedebugNode = biosNode.findKey ("PXEDebug");
+        if (!pxedebugNode.isNull())
+            mData->mPXEDebugEnabled = pxedebugNode.value <bool> ("enabled");
+    }
+
+    /* time offset (optional) */
+    {
+        Key timeOffsetNode = biosNode.findKey ("TimeOffset");
+        if (!timeOffsetNode.isNull())
+            mData->mTimeOffset = timeOffsetNode.value <LONG64> ("value");
+    }
+
+    /* IDE controller type (optional, for old machines that lack this node,
+     * defaults to PIIX3) */
+    {
+        mData->mIDEControllerType = IDEControllerType_IDEControllerPIIX3;
+
+        Key ideControllerNode = biosNode.findKey ("IDEController");
+        if (!ideControllerNode.isNull())
+        {
+            const char *typeStr = ideControllerNode.stringValue ("type");
+            if (strcmp (typeStr, "PIIX3") == 0)
+                mData->mIDEControllerType = IDEControllerType_IDEControllerPIIX3;
+            else if (strcmp (typeStr, "PIIX4") == 0)
+                mData->mIDEControllerType = IDEControllerType_IDEControllerPIIX4;
+            else
+                ComAssertMsgFailedRet (("Invalid boot menu mode '%s'\n", typeStr),
+                                       E_FAIL);
+        }
+    }
+
+    return S_OK;
+}
+
+/** 
+ *  Saves settings to the given machine node.
+ * 
+ *  @param aMachineNode <Machine> node.
+ * 
+ *  @note Locks this object for reading. 
+ */
+HRESULT BIOSSettings::saveSettings (settings::Key &aMachineNode)
+{
+    using namespace settings;
+
+    AssertReturn (!aMachineNode.isNull(), E_FAIL);
+
+    AutoCaller autoCaller (this);
+    AssertComRCReturnRC (autoCaller.rc());
+
+    AutoReaderLock alock (this);
+
+    Key biosNode = aMachineNode.createKey ("BIOS");
+
+    /* ACPI */
+    {
+        Key acpiNode = biosNode.createKey ("ACPI");
+        acpiNode.setValue <bool> ("enabled", !!mData->mACPIEnabled);
+    }
+
+    /* IOAPIC */
+    {
+        Key ioapicNode = biosNode.createKey ("IOAPIC");
+        ioapicNode.setValue <bool> ("enabled", !!mData->mIOAPICEnabled);
+    }
+
+    /* BIOS logo (optional) **/
+    {
+        Key logoNode = biosNode.createKey ("Logo");
+        logoNode.setValue <bool> ("fadeIn", !!mData->mLogoFadeIn);
+        logoNode.setValue <bool> ("fadeOut", !!mData->mLogoFadeOut);
+        logoNode.setValue <ULONG> ("displayTime", mData->mLogoDisplayTime);
+        logoNode.setValueOr <Bstr> ("imagePath", mData->mLogoImagePath, Bstr::Null);
+    }
+
+    /* boot menu (optional) */
+    {
+        Key bootMenuNode = biosNode.createKey ("BootMenu");
+        const char *modeStr = NULL;
+        switch (mData->mBootMenuMode)
+        {
+            case BIOSBootMenuMode_Disabled:
+                modeStr = "disabled";
+                break;
+            case BIOSBootMenuMode_MenuOnly:
+                modeStr = "menuonly";
+                break;
+            case BIOSBootMenuMode_MessageAndMenu:
+                modeStr = "messageandmenu";
+                break;
+            default:
+                ComAssertMsgFailedRet (("Invalid boot menu type: %d\n",
+                                        mData->mBootMenuMode),
+                                       E_FAIL);
+        }
+        bootMenuNode.setStringValue ("mode", modeStr);
+    }
+
+    /* time offset (optional) */
+    {
+        Key timeOffsetNode = biosNode.createKey ("TimeOffset");
+        timeOffsetNode.setValue <LONG64> ("value", mData->mTimeOffset);
+    }
+
+    /* PXE debug flag (optional) */
+    {
+        Key pxedebugNode = biosNode.createKey ("PXEDebug");
+        pxedebugNode.setValue <bool> ("enabled", !!mData->mPXEDebugEnabled);
+    }
+
+    /* IDE controller type */
+    {
+        Key ideControllerNode = biosNode.createKey ("IDEController");
+        const char *ideControllerTypeStr = NULL;
+        switch (mData->mIDEControllerType)
+        {
+            case IDEControllerType_IDEControllerPIIX3:
+                ideControllerTypeStr = "PIIX3";
+                break;
+            case IDEControllerType_IDEControllerPIIX4:
+                ideControllerTypeStr = "PIIX4";
+                break;
+            default:
+                ComAssertMsgFailedRet (("Invalid IDE Controller type: %d\n",
+                                        mData->mIDEControllerType),
+                                       E_FAIL);
+        }
+        ideControllerNode.setStringValue ("type", ideControllerTypeStr);
+    }
+
+    return S_OK;
+}
+
 void BIOSSettings::commit()
 {

trunk/src/VBox/Main/DVDDriveImpl.cpp

@@ -18 +18 @@
 #include "DVDDriveImpl.h"
 #include "MachineImpl.h"
+#include "HostImpl.h"
+#include "HostDVDDriveImpl.h"
 #include "VirtualBoxImpl.h"
+
 #include "Logging.h"
 
@@ -347 +350 @@
 // public methods only for internal purposes
 ////////////////////////////////////////////////////////////////////////////////
+
+/** 
+ *  Loads settings from the given machine node.
+ *  May be called once right after this object creation.
+ * 
+ *  @param aMachineNode <Machine> node.
+ * 
+ *  @note Locks this object for writing. 
+ */
+HRESULT DVDDrive::loadSettings (const settings::Key &aMachineNode)
+{
+    using namespace settings;
+
+    AssertReturn (!aMachineNode.isNull(), E_FAIL);
+
+    AutoCaller autoCaller (this);
+    AssertComRCReturnRC (autoCaller.rc());
+
+    AutoLock alock (this);
+
+    /* Note: we assume that the default values for attributes of optional
+     * nodes are assigned in the Data::Data() constructor and don't do it
+     * here. It implies that this method may only be called after constructing
+     * a new BIOSSettings object while all its data fields are in the default
+     * values. Exceptions are fields whose creation time defaults don't match
+     * values that should be applied when these fields are not explicitly set
+     * in the settings file (for backwards compatibility reasons). This takes
+     * place when a setting of a newly created object must default to A while
+     * the same setting of an object loaded from the old settings file must
+     * default to B. */ 
+
+    HRESULT rc = S_OK;
+
+    /* DVD drive (required, contains either Image or HostDrive or nothing) */
+    Key dvdDriveNode = aMachineNode.key ("DVDDrive");
+
+    /* optional, defaults to false */
+    mData->mPassthrough = dvdDriveNode.value <bool> ("passthrough");
+
+    Key typeNode;
+
+    if (!(typeNode = dvdDriveNode.findKey ("Image")).isNull())
+    {
+        Guid uuid = typeNode.value <Guid> ("uuid");
+        rc = MountImage (uuid);
+        CheckComRCReturnRC (rc);
+    }
+    else if (!(typeNode = dvdDriveNode.findKey ("HostDrive")).isNull())
+    {
+
+        Bstr src = typeNode.stringValue ("src");
+
+        /* find the correspoding object */
+        ComObjPtr <Host> host = mParent->virtualBox()->host();
+
+        ComPtr <IHostDVDDriveCollection> coll;
+        rc = host->COMGETTER(DVDDrives) (coll.asOutParam());
+        AssertComRC (rc);
+
+        ComPtr <IHostDVDDrive> drive;
+        rc = coll->FindByName (src, drive.asOutParam());
+        if (SUCCEEDED (rc))
+        {
+            rc = CaptureHostDrive (drive);
+            CheckComRCReturnRC (rc);
+        }
+        else if (rc == E_INVALIDARG)
+        {
+            /* the host DVD drive is not currently available. we
+             * assume it will be available later and create an
+             * extra object now */
+            ComObjPtr <HostDVDDrive> hostDrive;
+            hostDrive.createObject();
+            rc = hostDrive->init (src);
+            AssertComRC (rc);
+            rc = CaptureHostDrive (hostDrive);
+            CheckComRCReturnRC (rc);
+        }
+        else
+            AssertComRC (rc);
+    }
+
+    return S_OK;
+}
+
+/** 
+ *  Saves settings to the given machine node.
+ * 
+ *  @param aMachineNode <Machine> node.
+ * 
+ *  @note Locks this object for reading. 
+ */
+HRESULT DVDDrive::saveSettings (settings::Key &aMachineNode)
+{
+    using namespace settings;
+
+    AssertReturn (!aMachineNode.isNull(), E_FAIL);
+
+    AutoCaller autoCaller (this);
+    AssertComRCReturnRC (autoCaller.rc());
+
+    AutoReaderLock alock (this);
+
+    Key node = aMachineNode.createKey ("DVDDrive");
+
+    node.setValue <bool> ("passthrough", !!mData->mPassthrough);
+
+    switch (mData->mDriveState)
+    {
+        case DriveState_ImageMounted:
+        {
+            Assert (!mData->mDVDImage.isNull());
+
+            Guid id;
+            HRESULT rc = mData->mDVDImage->COMGETTER(Id) (id.asOutParam());
+            AssertComRC (rc);
+            Assert (!id.isEmpty());
+
+            Key imageNode = node.createKey ("Image");
+            imageNode.setValue <Guid> ("uuid", id);
+            break;
+        }
+        case DriveState_HostDriveCaptured:
+        {
+            Assert (!mData->mHostDrive.isNull());
+
+            Bstr name;
+            HRESULT  rc = mData->mHostDrive->COMGETTER(Name) (name.asOutParam());
+            AssertComRC (rc);
+            Assert (!name.isEmpty());
+
+            Key hostDriveNode = node.createKey ("HostDrive");
+            hostDriveNode.setValue <Bstr> ("src", name);
+            break;
+        }
+        case DriveState_NotMounted:
+            /* do nothing, i.e.leave the drive node empty */
+            break;
+        default:
+            ComAssertMsgFailedRet (("Invalid drive state: %d\n",
+                                      mData->mDriveState),
+                                     E_FAIL);
+    }
+
+    return S_OK;
+}
 
 /** 

trunk/src/VBox/Main/Doxyfile.Main

@@ -982 +982 @@
     CFGMGCDECL \
     CFGMDECL \
-    CFGLDRR3DECL \
     EMR3DECL \
     EMR0DECL \

trunk/src/VBox/Main/FloppyDriveImpl.cpp

@@ -18 +18 @@
 #include "FloppyDriveImpl.h"
 #include "MachineImpl.h"
+#include "HostImpl.h"
+#include "HostFloppyDriveImpl.h"
 #include "VirtualBoxImpl.h"
+
 #include "Logging.h"
 
@@ -354 +357 @@
 // public methods only for internal purposes
 /////////////////////////////////////////////////////////////////////////////
+
+/** 
+ *  Loads settings from the given machine node.
+ *  May be called once right after this object creation.
+ * 
+ *  @param aMachineNode <Machine> node.
+ * 
+ *  @note Locks this object for writing. 
+ */
+HRESULT FloppyDrive::loadSettings (const settings::Key &aMachineNode)
+{
+    using namespace settings;
+
+    AssertReturn (!aMachineNode.isNull(), E_FAIL);
+
+    AutoCaller autoCaller (this);
+    AssertComRCReturnRC (autoCaller.rc());
+
+    AutoLock alock (this);
+
+    /* Note: we assume that the default values for attributes of optional
+     * nodes are assigned in the Data::Data() constructor and don't do it
+     * here. It implies that this method may only be called after constructing
+     * a new BIOSSettings object while all its data fields are in the default
+     * values. Exceptions are fields whose creation time defaults don't match
+     * values that should be applied when these fields are not explicitly set
+     * in the settings file (for backwards compatibility reasons). This takes
+     * place when a setting of a newly created object must default to A while
+     * the same setting of an object loaded from the old settings file must
+     * default to B. */ 
+
+    HRESULT rc = S_OK;
+
+    /* Floppy drive (required, contains either Image or HostDrive or nothing) */
+    Key floppyDriveNode = aMachineNode.key ("FloppyDrive");
+
+    /* optional, defaults to true */
+    mData->mEnabled = floppyDriveNode.value <bool> ("enabled");
+
+    Key typeNode;
+
+    if (!(typeNode = floppyDriveNode.findKey ("Image")).isNull())
+    {
+        Guid uuid = typeNode.value <Guid> ("uuid");
+        rc = MountImage (uuid);
+        CheckComRCReturnRC (rc);
+    }
+    else if (!(typeNode = floppyDriveNode.findKey ("HostDrive")).isNull())
+    {
+
+        Bstr src = typeNode.stringValue ("src");
+
+        /* find the correspoding object */
+        ComObjPtr <Host> host = mParent->virtualBox()->host();
+
+        ComPtr <IHostFloppyDriveCollection> coll;
+        rc = host->COMGETTER(FloppyDrives) (coll.asOutParam());
+        AssertComRC (rc);
+
+        ComPtr <IHostFloppyDrive> drive;
+        rc = coll->FindByName (src, drive.asOutParam());
+        if (SUCCEEDED (rc))
+        {
+            rc = CaptureHostDrive (drive);
+            CheckComRCReturnRC (rc);
+        }
+        else if (rc == E_INVALIDARG)
+        {
+            /* the host DVD drive is not currently available. we
+             * assume it will be available later and create an
+             * extra object now */
+            ComObjPtr <HostFloppyDrive> hostDrive;
+            hostDrive.createObject();
+            rc = hostDrive->init (src);
+            AssertComRC (rc);
+            rc = CaptureHostDrive (hostDrive);
+            CheckComRCReturnRC (rc);
+        }
+        else
+            AssertComRC (rc);
+    }
+
+    return S_OK;
+}
+
+/** 
+ *  Saves settings to the given machine node.
+ * 
+ *  @param aMachineNode <Machine> node.
+ * 
+ *  @note Locks this object for reading. 
+ */
+HRESULT FloppyDrive::saveSettings (settings::Key &aMachineNode)
+{
+    using namespace settings;
+
+    AssertReturn (!aMachineNode.isNull(), E_FAIL);
+
+    AutoCaller autoCaller (this);
+    AssertComRCReturnRC (autoCaller.rc());
+
+    AutoReaderLock alock (this);
+
+    Key node = aMachineNode.createKey ("FloppyDrive");
+
+    node.setValue <bool> ("enabled", !!mData->mEnabled);
+
+    switch (mData->mDriveState)
+    {
+        case DriveState_ImageMounted:
+        {
+            Assert (!mData->mFloppyImage.isNull());
+
+            Guid id;
+            HRESULT rc = mData->mFloppyImage->COMGETTER(Id) (id.asOutParam());
+            AssertComRC (rc);
+            Assert (!id.isEmpty());
+
+            Key imageNode = node.createKey ("Image");
+            imageNode.setValue <Guid> ("uuid", id);
+            break;
+        }
+        case DriveState_HostDriveCaptured:
+        {
+            Assert (!mData->mHostDrive.isNull());
+
+            Bstr name;
+            HRESULT  rc = mData->mHostDrive->COMGETTER(Name) (name.asOutParam());
+            AssertComRC (rc);
+            Assert (!name.isEmpty());
+
+            Key hostDriveNode = node.createKey ("HostDrive");
+            hostDriveNode.setValue <Bstr> ("src", name);
+            break;
+        }
+        case DriveState_NotMounted:
+            /* do nothing, i.e.leave the drive node empty */
+            break;
+        default:
+            ComAssertMsgFailedRet (("Invalid drive state: %d\n",
+                                      mData->mDriveState),
+                                     E_FAIL);
+    }
+
+    return S_OK;
+}
 
 /** 

trunk/src/VBox/Main/HardDiskImpl.cpp

@@ -1187 +1187 @@
  *
  *  @param aHDNode      <HardDisk> node when #isDifferencing() = false, or
- *                      <DiffHardDisk> node otherwise
+ *                      <DiffHardDisk> node otherwise.
  *
  *  @note
  *      Must be called from under the object's lock
  */
-HRESULT HardDisk::loadSettings (CFGNODE aHDNode)
-{
-    AssertReturn (aHDNode, E_FAIL);
-
-    Guid uuid; /* uuid (required) */
-    CFGLDRQueryUUID (aHDNode, "uuid", uuid.ptr());
-    mId = uuid;
+HRESULT HardDisk::loadSettings (const settings::Key &aHDNode)
+{
+    using namespace settings;
+
+    AssertReturn (!aHDNode.isNull(), E_FAIL);
+
+    /* required */
+    mId = aHDNode.value <Guid> ("uuid");
 
     if (!isDifferencing())
     {
-        Bstr type; /* type (required for <HardDisk> nodes only) */
-        CFGLDRQueryBSTR (aHDNode, "type", type.asOutParam());
-        if (type == L"normal")
+        /* type required for <HardDisk> nodes only */
+        const char *type = aHDNode.stringValue ("type");
+        if (strcmp (type, "normal") == 0)
             mType = HardDiskType_NormalHardDisk;
-        else if (type == L"immutable")
+        else if (strcmp (type, "immutable") == 0)
             mType = HardDiskType_ImmutableHardDisk;
-        else if (type == L"writethrough")
+        else if (strcmp (type, "writethrough") == 0)
             mType = HardDiskType_WritethroughHardDisk;
         else
-            ComAssertMsgFailedRet (("Invalid hard disk type '%ls'\n", type.raw()),
+            ComAssertMsgFailedRet (("Invalid hard disk type '%s'\n", type),
                                    E_FAIL);
     }
@@ -1218 +1219 @@
 
     HRESULT rc = mVirtualBox->registerHardDisk (this, VirtualBox::RHD_OnStartUp);
-    if (FAILED (rc))
-        return rc;
+    CheckComRCReturnRC (rc);
 
     /* load all children */
-    unsigned count = 0;
-    CFGLDRCountChildren (aHDNode, "DiffHardDisk", &count);
-    for (unsigned i = 0; i < count && SUCCEEDED (rc); ++ i)
-    {
-        CFGNODE hdNode = 0;
-
-        CFGLDRGetChildNode (aHDNode, "DiffHardDisk", i, &hdNode);
-        ComAssertBreak (hdNode, rc = E_FAIL);
-
-        do
-        {
-            CFGNODE vdiNode = 0;
-            CFGLDRGetChildNode (hdNode, "VirtualDiskImage", 0, &vdiNode);
-            ComAssertBreak (vdiNode, rc = E_FAIL);
-
-            ComObjPtr <HVirtualDiskImage> vdi;
-            vdi.createObject();
-            rc = vdi->init (mVirtualBox, this, hdNode, vdiNode);
-
-            CFGLDRReleaseNode (vdiNode);
-        }
-        while (0);
-
-        CFGLDRReleaseNode (hdNode);
+    Key::List children = aHDNode.keys ("DiffHardDisk");
+    for (Key::List::const_iterator it = children.begin();
+         it != children.end(); ++ it)
+    {
+        Key vdiNode = (*it).key ("VirtualDiskImage");
+
+        ComObjPtr <HVirtualDiskImage> vdi;
+        vdi.createObject();
+        rc = vdi->init (mVirtualBox, this, (*it), vdiNode);
+        CheckComRCBreakRC (rc);
     }
 
@@ -1259 +1245 @@
  *
  *  @param aHDNode      <HardDisk> node when #isDifferencing() = false, or
- *                      <DiffHardDisk> node otherwise
+ *                      <DiffHardDisk> node otherwise.
  *
  *  @note
  *      Must be called from under the object's lock
  */
-HRESULT HardDisk::saveSettings (CFGNODE aHDNode)
-{
-    AssertReturn (aHDNode, E_FAIL);
+HRESULT HardDisk::saveSettings (settings::Key &aHDNode)
+{
+    using namespace settings;
+
+    AssertReturn (!aHDNode.isNull(), E_FAIL);
 
     /* uuid (required) */
-    CFGLDRSetUUID (aHDNode, "uuid", mId.ptr());
+    aHDNode.setValue <Guid> ("uuid", mId);
 
     if (!isDifferencing())
@@ -1287 +1275 @@
                 break;
         }
-        CFGLDRSetString (aHDNode, "type", type);
-    }
-
-    HRESULT rc = S_OK;
+        aHDNode.setStringValue ("type", type);
+    }
 
     /* save all children */
     AutoLock chLock (childrenLock());
     for (HardDiskList::const_iterator it = children().begin();
-         it != children().end() && SUCCEEDED (rc);
+         it != children().end();
          ++ it)
     {
@@ -1301 +1287 @@
         AutoLock childLock (child);
 
-        CFGNODE hdNode = 0;
-        CFGLDRAppendChildNode (aHDNode, "DiffHardDisk", &hdNode);
-        ComAssertBreak (hdNode, rc = E_FAIL);
-
-        do
-        {
-            CFGNODE vdiNode = 0;
-            CFGLDRAppendChildNode (hdNode, "VirtualDiskImage", &vdiNode);
-            ComAssertBreak (vdiNode, rc = E_FAIL);
-
-            rc = child->saveSettings (hdNode, vdiNode);
-
-            CFGLDRReleaseNode (vdiNode);
-        }
-        while (0);
-
-        CFGLDRReleaseNode (hdNode);
-    }
-
-    return rc;
+        Key hdNode = aHDNode.appendKey ("DiffHardDisk");
+
+        {
+            Key vdiNode = hdNode.createKey ("VirtualDiskImage");
+            HRESULT rc = child->saveSettings (hdNode, vdiNode);
+            CheckComRCReturnRC (rc);
+        }
+    }
+
+    return S_OK;
 }
 
@@ -1363 +1339 @@
  *  registered on success.
  *
- *  @param aHDNode      <HardDisk> node
- *  @param aVDINode     <VirtualDiskImage> node
+ *  @param aHDNode      <HardDisk> or <DiffHardDisk> node.
+ *  @param aVDINode     <VirtualDiskImage> node.
  */
 HRESULT HVirtualDiskImage::init (VirtualBox *aVirtualBox, HardDisk *aParent,
-                                 CFGNODE aHDNode, CFGNODE aVDINode)
-{
-    LogFlowThisFunc (("aHDNode=%p, aVDINode=%p\n", aHDNode, aVDINode));
-
-    AssertReturn (aHDNode && aVDINode, E_FAIL);
+                                 const settings::Key &aHDNode,
+                                 const settings::Key &aVDINode)
+{
+    using namespace settings;
+
+    LogFlowThisFunc (("\n"));
+
+    AssertReturn (!aHDNode.isNull() && !aVDINode.isNull(), E_FAIL);
 
     AutoLock alock (this);
@@ -1389 +1368 @@
 
         /* filePath (required) */
-        Bstr filePath;
-        CFGLDRQueryBSTR (aVDINode, "filePath", filePath.asOutParam());
-
+        Bstr filePath = aVDINode.stringValue ("filePath");
         rc = setFilePath (filePath);
         CheckComRCBreakRC (rc);
@@ -1768 +1745 @@
  *  all children to the specified hard disk node
  *
- *  @param aHDNode      <HardDisk> or <DiffHardDisk> node
- *  @param aStorageNode <VirtualDiskImage> node
- */
-HRESULT HVirtualDiskImage::saveSettings (CFGNODE aHDNode, CFGNODE aStorageNode)
-{
-    AssertReturn (aHDNode && aStorageNode, E_FAIL);
-
-    AutoLock alock (this);
-    CHECK_READY();
-
-    // filePath (required)
-    CFGLDRSetBSTR (aStorageNode, "filePath", mFilePath);
-
-    // save basic settings and children
+ *  @param aHDNode      <HardDisk> or <DiffHardDisk> node.
+ *  @param aStorageNode <VirtualDiskImage> node.
+ */
+HRESULT HVirtualDiskImage::saveSettings (settings::Key &aHDNode,
+                                         settings::Key &aStorageNode)
+{
+    AssertReturn (!aHDNode.isNull() && !aStorageNode.isNull(), E_FAIL);
+
+    AutoLock alock (this);
+    CHECK_READY();
+
+    /* filePath (required) */
+    aStorageNode.setValue <Bstr> ("filePath", mFilePath);
+
+    /* save basic settings and children */
     return HardDisk::saveSettings (aHDNode);
 }
@@ -2834 +2812 @@
  *  registered on success.
  *
- *  @param aHDNode      <HardDisk> node
- *  @param aVDINod      <ISCSIHardDisk> node
+ *  @param aHDNode      <HardDisk> node.
+ *  @param aVDINod      <ISCSIHardDisk> node.
  */
 HRESULT HISCSIHardDisk::init (VirtualBox *aVirtualBox,
-                              CFGNODE aHDNode, CFGNODE aISCSINode)
-{
-    LogFlowThisFunc (("aHDNode=%p, aISCSINode=%p\n", aHDNode, aISCSINode));
-
-    AssertReturn (aHDNode && aISCSINode, E_FAIL);
+                              const settings::Key &aHDNode,
+                              const settings::Key &aISCSINode)
+{
+    using namespace settings;
+
+    LogFlowThisFunc (("\n"));
+
+    AssertReturn (!aHDNode.isNull() && !aISCSINode.isNull(), E_FAIL);
 
     AutoLock alock (this);
@@ -2860 +2841 @@
 
         /* server (required) */
-        CFGLDRQueryBSTR (aISCSINode, "server", mServer.asOutParam());
+        mServer = aISCSINode.stringValue ("server");
         /* target (required) */
-        CFGLDRQueryBSTR (aISCSINode, "target", mTarget.asOutParam());
+        mTarget = aISCSINode.stringValue ("target");
 
         /* port (optional) */
-        CFGLDRQueryUInt16 (aISCSINode, "port", &mPort);
+        mPort = aISCSINode.value <USHORT> ("port");
         /* lun (optional) */
-        CFGLDRQueryUInt64 (aISCSINode, "lun", &mLun);
+        mLun = aISCSINode.value <ULONG64> ("lun");
         /* userName (optional) */
-        CFGLDRQueryBSTR (aISCSINode, "userName", mUserName.asOutParam());
+        mUserName = aISCSINode.stringValue ("userName");
         /* password (optional) */
-        CFGLDRQueryBSTR (aISCSINode, "password", mPassword.asOutParam());
+        mPassword = aISCSINode.stringValue ("password");
 
         LogFlowThisFunc (("'iscsi:%ls:%hu@%ls/%ls:%llu'\n",
@@ -3237 +3218 @@
  *  all children to the specified hard disk node
  *
- *  @param aHDNode      <HardDisk>
- *  @param aStorageNode <ISCSIHardDisk> node
- */
-HRESULT HISCSIHardDisk::saveSettings (CFGNODE aHDNode, CFGNODE aStorageNode)
-{
-    AssertReturn (aHDNode && aStorageNode, E_FAIL);
+ *  @param aHDNode      <HardDisk>.
+ *  @param aStorageNode <ISCSIHardDisk> node.
+ */
+HRESULT HISCSIHardDisk::saveSettings (settings::Key &aHDNode,
+                                      settings::Key &aStorageNode)
+{
+    AssertReturn (!aHDNode.isNull() && !aStorageNode.isNull(), E_FAIL);
 
     AutoLock alock (this);
@@ -3248 +3230 @@
 
     /* server (required) */
-    CFGLDRSetBSTR (aStorageNode, "server", mServer);
+    aStorageNode.setValue <Bstr> ("server", mServer);
     /* target (required) */
-    CFGLDRSetBSTR (aStorageNode, "target", mTarget);
-
-    /* port (optional) */
-    if (mPort != 0)
-        CFGLDRSetUInt16 (aStorageNode, "port", mPort);
-    else
-        CFGLDRDeleteAttribute (aStorageNode, "port");
+    aStorageNode.setValue <Bstr> ("target", mTarget);
+
+    /* port (optional, defaults to 0) */
+    aStorageNode.setValueOr <USHORT> ("port", mPort, 0);
     /* lun (optional, force 0x format to coform to XML Schema!) */
-    if (mLun != 0)
-        CFGLDRSetUInt64Ex (aStorageNode, "lun", mLun, 16);
-    else
-        CFGLDRDeleteAttribute (aStorageNode, "lun");
+    aStorageNode.setValueOr <ULONG64> ("lun", mLun, 0, 16);
     /* userName (optional) */
-    if (!mUserName.isNull())
-        CFGLDRSetBSTR (aStorageNode, "userName", mUserName);
-    else
-        CFGLDRDeleteAttribute (aStorageNode, "userName");
+    aStorageNode.setValueOr <Bstr> ("userName", mUserName, Bstr::Null);
     /* password (optional) */
-    if (!mPassword.isNull())
-        CFGLDRSetBSTR (aStorageNode, "password", mPassword);
-    else
-        CFGLDRDeleteAttribute (aStorageNode, "password");
+    aStorageNode.setValueOr <Bstr> ("password", mPassword, Bstr::Null);
 
     /* save basic settings and children */
@@ -3422 +3392 @@
  *  registered on success.
  *
- *  @param aHDNode      <HardDisk> node
- *  @param aVMDKNode    <VirtualDiskImage> node
+ *  @param aHDNode      <HardDisk> node.
+ *  @param aVMDKNode    <VirtualDiskImage> node.
  */
 HRESULT HVMDKImage::init (VirtualBox *aVirtualBox, HardDisk *aParent,
-                          CFGNODE aHDNode, CFGNODE aVMDKNode)
-{
-    LogFlowThisFunc (("aHDNode=%p, aVMDKNode=%p\n", aHDNode, aVMDKNode));
-
-    AssertReturn (aHDNode && aVMDKNode, E_FAIL);
+                          const settings::Key &aHDNode, 
+                          const settings::Key &aVMDKNode)
+{
+    using namespace settings;
+
+    LogFlowThisFunc (("\n"));
+
+    AssertReturn (!aHDNode.isNull() && !aVMDKNode.isNull(), E_FAIL);
 
     AutoLock alock (this);
@@ -3448 +3421 @@
 
         /* filePath (required) */
-        Bstr filePath;
-        CFGLDRQueryBSTR (aVMDKNode, "filePath", filePath.asOutParam());
-
+        Bstr filePath = aVMDKNode.stringValue ("filePath");
         rc = setFilePath (filePath);
         CheckComRCBreakRC (rc);
@@ -3858 +3829 @@
  *  all children to the specified hard disk node
  *
- *  @param aHDNode      <HardDisk> or <DiffHardDisk> node
- *  @param aStorageNode <VirtualDiskImage> node
- */
-HRESULT HVMDKImage::saveSettings (CFGNODE aHDNode, CFGNODE aStorageNode)
-{
-    AssertReturn (aHDNode && aStorageNode, E_FAIL);
+ *  @param aHDNode      <HardDisk> or <DiffHardDisk> node.
+ *  @param aStorageNode <VirtualDiskImage> node.
+ */
+HRESULT HVMDKImage::saveSettings (settings::Key &aHDNode,
+                                  settings::Key &aStorageNode)
+{
+    AssertReturn (!aHDNode.isNull() && !aStorageNode.isNull(), E_FAIL);
 
     AutoLock alock (this);
@@ -3869 +3841 @@
 
     /* filePath (required) */
-    CFGLDRSetBSTR (aStorageNode, "filePath", mFilePath);
+    aStorageNode.setValue <Bstr> ("filePath", mFilePath);
 
     /* save basic settings and children */
@@ -4291 +4263 @@
  *  registered on success.
  *
- *  @param aHDNode      <HardDisk> node
- *  @param aCustomNode  <VirtualDiskImage> node
+ *  @param aHDNode      <HardDisk> node.
+ *  @param aCustomNode  <VirtualDiskImage> node.
  */
 HRESULT HCustomHardDisk::init (VirtualBox *aVirtualBox, HardDisk *aParent,
-                          CFGNODE aHDNode, CFGNODE aCustomNode)
-{
-    LogFlowThisFunc (("aHDNode=%p, aCustomNode=%p\n", aHDNode, aCustomNode));
-
-    AssertReturn (aHDNode && aCustomNode, E_FAIL);
+                               const settings::Key &aHDNode,
+                               const settings::Key &aCustomNode)
+{
+    using namespace settings;
+
+    LogFlowThisFunc (("\n"));
+
+    AssertReturn (!aHDNode.isNull() && !aCustomNode.isNull(), E_FAIL);
 
     AutoLock alock (this);
@@ -4317 +4292 @@
 
         /* location (required) */
-        Bstr location;
-        CFGLDRQueryBSTR (aCustomNode, "location", location.asOutParam());
-
+        Bstr location = aCustomNode.stringValue ("location");
         rc = setLocation (location);
         CheckComRCBreakRC (rc);
@@ -4326 +4299 @@
 
         /* format (required) */
-        CFGLDRQueryBSTR (aCustomNode, "format", mFormat.asOutParam());
+        mFormat = aCustomNode.stringValue ("format");
 
         /* initialize the container */
@@ -4732 +4705 @@
  *  all children to the specified hard disk node
  *
- *  @param aHDNode      <HardDisk> or <DiffHardDisk> node
- *  @param aStorageNode <VirtualDiskImage> node
- */
-HRESULT HCustomHardDisk::saveSettings (CFGNODE aHDNode, CFGNODE aStorageNode)
-{
-    AssertReturn (aHDNode && aStorageNode, E_FAIL);
+ *  @param aHDNode      <HardDisk> or <DiffHardDisk> node.
+ *  @param aStorageNode <VirtualDiskImage> node.
+ */
+HRESULT HCustomHardDisk::saveSettings (settings::Key &aHDNode,
+                                       settings::Key &aStorageNode)
+{
+    AssertReturn (!aHDNode.isNull() && !aStorageNode.isNull(), E_FAIL);
 
     AutoLock alock (this);
@@ -4743 +4717 @@
 
     /* location (required) */
-    CFGLDRSetBSTR (aStorageNode, "location", mLocationFull);
+    aStorageNode.setValue <Bstr> ("location", mLocationFull);
 
     /* format (required) */
-    CFGLDRSetBSTR (aStorageNode, "format", mFormat);
+    aStorageNode.setValue <Bstr> ("format", mFormat);
 
     /* save basic settings and children */

trunk/src/VBox/Main/HostImpl.cpp

@@ -1133 +1133 @@
 }
 
-HRESULT Host::loadSettings (CFGNODE aGlobal)
-{
+HRESULT Host::loadSettings (const settings::Key &aGlobal)
+{
+    using namespace settings;
+
     AutoLock lock (this);
     CHECK_READY();
 
-    ComAssertRet (aGlobal, E_FAIL);
-
-    CFGNODE filters = NULL;
-    CFGLDRGetChildNode (aGlobal, "USBDeviceFilters", 0, &filters);
-    Assert (filters);
+    AssertReturn (!aGlobal.isNull(), E_FAIL);
 
     HRESULT rc = S_OK;
 
-    unsigned filterCount = 0;
-    CFGLDRCountChildren (filters, "DeviceFilter", &filterCount);
-    for (unsigned i = 0; i < filterCount && SUCCEEDED (rc); i++)
-    {
-        CFGNODE filter = NULL;
-        CFGLDRGetChildNode (filters, "DeviceFilter", i, &filter);
-        Assert (filter);
-
-        Bstr name;
-        CFGLDRQueryBSTR (filter, "name", name.asOutParam());
-        bool active;
-        CFGLDRQueryBool (filter, "active", &active);
-
-        Bstr vendorId;
-        CFGLDRQueryBSTR (filter, "vendorid", vendorId.asOutParam());
-        Bstr productId;
-        CFGLDRQueryBSTR (filter, "productid", productId.asOutParam());
-        Bstr revision;
-        CFGLDRQueryBSTR (filter, "revision", revision.asOutParam());
-        Bstr manufacturer;
-        CFGLDRQueryBSTR (filter, "manufacturer", manufacturer.asOutParam());
-        Bstr product;
-        CFGLDRQueryBSTR (filter, "product", product.asOutParam());
-        Bstr serialNumber;
-        CFGLDRQueryBSTR (filter, "serialnumber", serialNumber.asOutParam());
-        Bstr port;
-        CFGLDRQueryBSTR (filter, "port", port.asOutParam());
+    Key::List filters = aGlobal.key ("USBDeviceFilters").keys ("DeviceFilter");
+    for (Key::List::const_iterator it = filters.begin();
+         it != filters.end(); ++ it)
+    {
+        Bstr name = (*it).stringValue ("name");
+        bool active = (*it).value <bool> ("active");
+
+        Bstr vendorId = (*it).stringValue ("vendorid");
+        Bstr productId = (*it).stringValue ("productid");
+        Bstr revision = (*it).stringValue ("revision");
+        Bstr manufacturer = (*it).stringValue ("manufacturer");
+        Bstr product = (*it).stringValue ("product");
+        Bstr serialNumber = (*it).stringValue ("serialnumber");
+        Bstr port = (*it).stringValue ("port");
 
         USBDeviceFilterAction_T action;
         action = USBDeviceFilterAction_USBDeviceFilterIgnore;
-        Bstr actionStr;
-        CFGLDRQueryBSTR (filter, "action", actionStr.asOutParam());
-        if (actionStr == L"Ignore")
+        const char *actionStr = (*it).stringValue ("action");
+        if (strcmp (actionStr, "Ignore") == 0)
             action = USBDeviceFilterAction_USBDeviceFilterIgnore;
         else
-        if (actionStr == L"Hold")
+        if (strcmp (actionStr, "Hold") == 0)
             action = USBDeviceFilterAction_USBDeviceFilterHold;
         else
-            AssertMsgFailed (("Invalid action: %ls\n", actionStr.raw()));
+            AssertMsgFailed (("Invalid action: '%s'\n", actionStr));
 
         ComObjPtr <HostUSBDeviceFilter> filterObj;
@@ -1192 +1176 @@
                               manufacturer, product, serialNumber, port,
                               action);
-        // error info is set by init() when appropriate
-        if (SUCCEEDED (rc))
-        {
-            mUSBDeviceFilters.push_back (filterObj);
-            filterObj->mInList = true;
-
-            // notify the proxy (only when the filter is active)
-            if (filterObj->data().mActive)
-            {
-                HostUSBDeviceFilter *flt = filterObj; // resolve ambiguity
+        /* error info is set by init() when appropriate */
+        CheckComRCBreakRC (rc);
+
+        mUSBDeviceFilters.push_back (filterObj);
+        filterObj->mInList = true;
+
+        /* notify the proxy (only when the filter is active) */
+        if (filterObj->data().mActive)
+        {
+            HostUSBDeviceFilter *flt = filterObj; /* resolve ambiguity */
 #ifndef VBOX_WITH_USBFILTER
-                flt->id() =
-                    mUSBProxyService->insertFilter (ComPtr <IUSBDeviceFilter> (flt));
+            flt->id() =
+                mUSBProxyService->insertFilter (ComPtr <IUSBDeviceFilter> (flt));
 #else
-                flt->id() = mUSBProxyService->insertFilter (&filterObj->data().mUSBFilter);
+            flt->id() = mUSBProxyService->insertFilter (&filterObj->data().mUSBFilter);
 #endif
-            }
-        }
-
-        CFGLDRReleaseNode (filter);
-    }
-
-    CFGLDRReleaseNode (filters);
+        }
+    }
 
     return rc;
 }
 
-HRESULT Host::saveSettings (CFGNODE aGlobal)
-{
+HRESULT Host::saveSettings (settings::Key &aGlobal)
+{
+    using namespace settings;
+
     AutoLock lock (this);
     CHECK_READY();
 
-    ComAssertRet (aGlobal, E_FAIL);
-
-    // first, delete the entry
-    CFGNODE filters = NULL;
-    int vrc = CFGLDRGetChildNode (aGlobal, "USBDeviceFilters", 0, &filters);
-    if (VBOX_SUCCESS (vrc))
-    {
-        vrc = CFGLDRDeleteNode (filters);
-        ComAssertRCRet (vrc, E_FAIL);
-    }
-    // then, recreate it
-    vrc = CFGLDRCreateChildNode (aGlobal, "USBDeviceFilters", &filters);
-    ComAssertRCRet (vrc, E_FAIL);
+    ComAssertRet (!aGlobal.isNull(), E_FAIL);
+
+    /* first, delete the entry */
+    Key filters = aGlobal.findKey ("USBDeviceFilters");
+    if (!filters.isNull())
+        filters.zap();
+    /* then, recreate it */
+    filters = aGlobal.createKey ("USBDeviceFilters");
 
     USBDeviceFilterList::const_iterator it = mUSBDeviceFilters.begin();
@@ -1244 +1220 @@
         const HostUSBDeviceFilter::Data &data = (*it)->data();
 
-        CFGNODE filter = NULL;
-        CFGLDRAppendChildNode (filters, "DeviceFilter",  &filter);
-
-        CFGLDRSetBSTR (filter, "name", data.mName);
-        CFGLDRSetBool (filter, "active", !!data.mActive);
+        Key filter = filters.appendKey ("DeviceFilter");
+
+        filter.setValue <Bstr> ("name", data.mName);
+        filter.setValue <bool> ("active", !!data.mActive);
 
 #ifndef VBOX_WITH_USBFILTER
-        // all are optional
+
+        /* all are optional */
         if (data.mVendorId.string())
-            CFGLDRSetBSTR (filter, "vendorid", data.mVendorId.string());
+            filter.setValue <Bstr> ("vendorid", data.mVendorId.string());
         if (data.mProductId.string())
-            CFGLDRSetBSTR (filter, "productid", data.mProductId.string());
+            filter.setValue <Bstr> ("productid", data.mProductId.string());
         if (data.mRevision.string())
-            CFGLDRSetBSTR (filter, "revision", data.mRevision.string());
+            filter.setValue <Bstr> ("revision", data.mRevision.string());
         if (data.mManufacturer.string())
-            CFGLDRSetBSTR (filter, "manufacturer", data.mManufacturer.string());
+            filter.setValue <Bstr> ("manufacturer", data.mManufacturer.string());
         if (data.mProduct.string())
-            CFGLDRSetBSTR (filter, "product", data.mProduct.string());
+            filter.setValue <Bstr> ("product", data.mProduct.string());
         if (data.mSerialNumber.string())
-            CFGLDRSetBSTR (filter, "serialnumber", data.mSerialNumber.string());
+            filter.setValue <Bstr> ("serialnumber", data.mSerialNumber.string());
         if (data.mPort.string())
-            CFGLDRSetBSTR (filter, "port", data.mPort.string());
-
-        // action is mandatory
+            filter.setValue <Bstr> ("port", data.mPort.string());
+
+        /* action is mandatory */
         if (data.mAction == USBDeviceFilterAction_USBDeviceFilterIgnore)
-            CFGLDRSetString (filter, "action", "Ignore");
+            filter.setStringValue ("action", "Ignore");
         else
         if (data.mAction == USBDeviceFilterAction_USBDeviceFilterHold)
-            CFGLDRSetString (filter, "action", "Hold");
+            filter.setStringValue ("action", "Hold");
         else
             AssertMsgFailed (("Invalid action: %d\n", data.mAction));
 
 #else  /* VBOX_WITH_USBFILTER */
-        // all are optional
+
+        /* all are optional */
         Bstr str;
         (*it)->COMGETTER (VendorId) (str.asOutParam());
         if (!str.isNull())
-            CFGLDRSetBSTR (filter, "vendorid", str);
+            filter.setValue <Bstr> ("vendorid", str);
 
         (*it)->COMGETTER (ProductId) (str.asOutParam());
         if (!str.isNull())
-            CFGLDRSetBSTR (filter, "productid", str);
+            filter.setValue <Bstr> ("productid", str);
 
         (*it)->COMGETTER (Revision) (str.asOutParam());
         if (!str.isNull())
-            CFGLDRSetBSTR (filter, "revision", str);
+            filter.setValue <Bstr> ("revision", str);
 
         (*it)->COMGETTER (Manufacturer) (str.asOutParam());
         if (!str.isNull())
-            CFGLDRSetBSTR (filter, "manufacturer", str);
+            filter.setValue <Bstr> ("manufacturer", str);
 
         (*it)->COMGETTER (Product) (str.asOutParam());
         if (!str.isNull())
-            CFGLDRSetBSTR (filter, "product", str);
+            filter.setValue <Bstr> ("product", str);
 
         (*it)->COMGETTER (SerialNumber) (str.asOutParam());
         if (!str.isNull())
-            CFGLDRSetBSTR (filter, "serialnumber", str);
+            filter.setValue <Bstr> ("serialnumber", str);
 
         (*it)->COMGETTER (Port) (str.asOutParam());
         if (!str.isNull())
-            CFGLDRSetBSTR (filter, "port", str);
-
-        // action is mandatory
+            filter.setValue <Bstr> ("port", str);
+
+        /* action is mandatory */
         ULONG action = USBDeviceFilterAction_InvalidUSBDeviceFilterAction;
         (*it)->COMGETTER (Action) (&action);
         if (action == USBDeviceFilterAction_USBDeviceFilterIgnore)
-            CFGLDRSetString (filter, "action", "Ignore");
+            filter.setStringValue ("action", "Ignore");
         else if (action == USBDeviceFilterAction_USBDeviceFilterHold)
-            CFGLDRSetString (filter, "action", "Hold");
+            filter.setStringValue ("action", "Hold");
         else
             AssertMsgFailed (("Invalid action: %d\n", action));
+
 #endif /* VBOX_WITH_USBFILTER */
 
-        CFGLDRReleaseNode (filter);
-
         ++ it;
     }
-
-    CFGLDRReleaseNode (filters);
 
     return S_OK;

trunk/src/VBox/Main/MachineDebuggerImpl.cpp

@@ -173 +173 @@
 
     char *pszSnapshot;
-    int vrc = STAMR3Snapshot(pVM, Utf8Str(aPattern).raw(), &pszSnapshot, NULL, aWithDescriptions);
+    int vrc = STAMR3Snapshot(pVM, Utf8Str(aPattern).raw(), &pszSnapshot, NULL,
+                             !!aWithDescriptions);
     if (RT_FAILURE(vrc))
         return vrc == VERR_NO_MEMORY ? E_OUTOFMEMORY : E_FAIL;

trunk/src/VBox/Main/MachineImpl.cpp

@@ -31 +31 @@
 #include "MachineImpl.h"
 #include "HardDiskImpl.h"
-#include "HostDVDDriveImpl.h"
-#include "HostFloppyDriveImpl.h"
 #include "ProgressImpl.h"
 #include "HardDiskAttachmentImpl.h"
@@ -45 +43 @@
 #include "USBProxyService.h"
 
+#include "VirtualBoxXMLUtil.h"
+
 #include "Logging.h"
 
@@ -58 +58 @@
 
 #include <VBox/err.h>
-#include <VBox/cfgldr.h>
 #include <VBox/param.h>
 
 #include <algorithm>
+
+#include <typeinfo>
 
 #if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
@@ -116 +117 @@
 
     mMachineState = MachineState_PoweredOff;
-    RTTIMESPEC time;
-    mLastStateChange = RTTimeSpecGetMilli (RTTimeNow (&time));
+    RTTimeNow (&mLastStateChange);
 
     mMachineStateDeps = 0;
@@ -1399 +1399 @@
     AutoReaderLock alock (this);
 
-    *aLastStateChange = mData->mLastStateChange;
+    *aLastStateChange = RTTimeSpecGetMilli (&mData->mLastStateChange);
 
     return S_OK;
@@ -1930 +1930 @@
 }
 
+/**
+ *  @note Locks this object for reading.
+ */
 STDMETHODIMP Machine::GetNextExtraDataKey (INPTR BSTR aKey, BSTR *aNextKey, BSTR *aNextValue)
 {
@@ -1942 +1945 @@
     /* start with nothing found */
     *aNextKey = NULL;
-
-    /*
-     *  if we're ready and isConfigLocked() is FALSE then it means
-     *  that no config file exists yet, so return shortly
-     */
+    if (aNextValue)
+        *aNextValue = NULL;
+
+    /* if we're ready and isConfigLocked() is FALSE then it means
+     * that no config file exists yet, so return shortly */
     if (!isConfigLocked())
         return S_OK;
@@ -1952 +1955 @@
     HRESULT rc = S_OK;
 
-    /* load the config file */
-    CFGHANDLE configLoader = 0;
-    rc = openConfigLoader (&configLoader);
-    if (FAILED (rc))
-        return  E_FAIL;
-
-    CFGNODE machineNode;
-    CFGNODE extraDataNode;
-
-    /* navigate to the right position */
-    if (VBOX_SUCCESS(CFGLDRGetNode(configLoader, "VirtualBox/Machine", 0, &machineNode)) &&
-        VBOX_SUCCESS(CFGLDRGetChildNode(machineNode, "ExtraData", 0, &extraDataNode)))
-    {
-        /* check if it exists */
-        bool found = false;
-        unsigned count;
-        CFGNODE extraDataItemNode;
-        CFGLDRCountChildren(extraDataNode, "ExtraDataItem", &count);
-        for (unsigned i = 0; (i < count) && (found == false); i++)
-        {
-            Bstr name;
-            CFGLDRGetChildNode(extraDataNode, "ExtraDataItem", i, &extraDataItemNode);
-            CFGLDRQueryBSTR(extraDataItemNode, "name", name.asOutParam());
-
-            /* if we're supposed to return the first one */
-            if (aKey == NULL)
+    try
+    {
+        using namespace settings;
+
+        /* load the config file */
+        File file (File::ReadWrite, mData->mHandleCfgFile,
+                   Utf8Str (mData->mConfigFileFull));
+        XmlTreeBackend tree;
+
+        rc = VirtualBox::loadSettingsTree_Again (tree, file);
+        CheckComRCReturnRC (rc);
+
+        Key machineNode = tree.rootKey().key ("Machine");
+        Key extraDataNode = machineNode.findKey ("ExtraData");
+
+        if (!extraDataNode.isNull())
+        {
+            Key::List items = extraDataNode.keys ("ExtraDataItem");
+            if (items.size())
             {
-                name.cloneTo(aNextKey);
-                if (aNextValue)
-                    CFGLDRQueryBSTR(extraDataItemNode, "value", aNextValue);
-                found = true;
-            }
-            /* did we find the key we're looking for? */
-            else if (name == aKey)
-            {
-                found = true;
-                /* is there another item? */
-                if (i + 1 < count)
+                for (Key::List::const_iterator it = items.begin();
+                     it != items.end(); ++ it)
                 {
-                    CFGLDRGetChildNode(extraDataNode, "ExtraDataItem", i + 1, &extraDataItemNode);
-                    CFGLDRQueryBSTR(extraDataItemNode, "name", name.asOutParam());
-                    name.cloneTo(aNextKey);
-                    if (aNextValue)
-                        CFGLDRQueryBSTR(extraDataItemNode, "value", aNextValue);
-                    found = true;
-                }
-                else
-                {
-                    /* it's the last one */
-                    *aNextKey = NULL;
+                    Bstr key = (*it).stringValue ("name");
+
+                    /* if we're supposed to return the first one */
+                    if (aKey == NULL)
+                    {
+                        key.cloneTo (aNextKey);
+                        if (aNextValue)
+                        {
+                            Bstr val = (*it).stringValue ("value");
+                            val.cloneTo (aNextValue);
+                        }
+                        return S_OK;
+                    }
+
+                    /* did we find the key we're looking for? */
+                    if (key == aKey)
+                    {
+                        ++ it;
+                        /* is there another item? */
+                        if (it != items.end())
+                        {
+                            Bstr key = (*it).stringValue ("name");
+                            key.cloneTo (aNextKey);
+                            if (aNextValue)
+                            {
+                                Bstr val = (*it).stringValue ("value");
+                                val.cloneTo (aNextValue);
+                            }
+                        }
+                        /* else it's the last one, arguments are already NULL */
+                        return S_OK;
+                    }
                 }
             }
-            CFGLDRReleaseNode(extraDataItemNode);
-        }
-
-        /* if we haven't found the key, it's an error */
-        if (!found)
-            rc = setError(E_FAIL, tr("Could not find extra data key"));
-
-        CFGLDRReleaseNode(extraDataNode);
-        CFGLDRReleaseNode(machineNode);
-    }
-
-    closeConfigLoader (configLoader, false /* aSaveBeforeClose */);
+        }
+
+        /* Here we are when a) there are no items at all or b) there are items
+         * but none of them equals to the requested non-NULL key. b) is an
+         * error as well as a) if the key is non-NULL. When the key is NULL
+         * (which is the case only when there are no items), we just fall
+         * through to return NULLs and S_OK. */
+
+        if (aKey != NULL)
+            return setError (E_FAIL,
+                tr ("Could not find the extra data key '%ls'"), aKey);
+    }
+    catch (...)
+    {
+        rc = VirtualBox::handleUnexpectedExceptions (RT_SRC_POS);
+    }
 
     return rc;
 }
 
+/**
+ *  @note Locks this object for reading.
+ */
 STDMETHODIMP Machine::GetExtraData (INPTR BSTR aKey, BSTR *aValue)
 {
@@ -2035 +2050 @@
     *aValue = NULL;
 
-    /*
-     *  if we're ready and isConfigLocked() is FALSE then it means
-     *  that no config file exists yet, so return shortly
-     */
+    /* if we're ready and isConfigLocked() is FALSE then it means
+     * that no config file exists yet, so return shortly */
     if (!isConfigLocked())
         return S_OK;
@@ -2044 +2057 @@
     HRESULT rc = S_OK;
 
-    /* load the config file */
-    CFGHANDLE configLoader = 0;
-    rc = openConfigLoader (&configLoader);
-    if (FAILED (rc))
-        return  E_FAIL;
-
-    CFGNODE machineNode;
-    CFGNODE extraDataNode;
-
-    /* navigate to the right position */
-    if (VBOX_SUCCESS(CFGLDRGetNode(configLoader, "VirtualBox/Machine", 0, &machineNode)) &&
-        VBOX_SUCCESS(CFGLDRGetChildNode(machineNode, "ExtraData", 0, &extraDataNode)))
-    {
-        /* check if it exists */
-        bool found = false;
-        unsigned count;
-        CFGNODE extraDataItemNode;
-        CFGLDRCountChildren(extraDataNode, "ExtraDataItem", &count);
-        for (unsigned i = 0; (i < count) && (found == false); i++)
-        {
-            Bstr name;
-            CFGLDRGetChildNode(extraDataNode, "ExtraDataItem", i, &extraDataItemNode);
-            CFGLDRQueryBSTR(extraDataItemNode, "name", name.asOutParam());
-            if (name == aKey)
+    try
+    {
+        using namespace settings;
+
+        /* load the config file */
+        File file (File::ReadWrite, mData->mHandleCfgFile,
+                   Utf8Str (mData->mConfigFileFull));
+        XmlTreeBackend tree;
+
+        rc = VirtualBox::loadSettingsTree_Again (tree, file);
+        CheckComRCReturnRC (rc);
+
+        const Utf8Str key = aKey;
+
+        Key machineNode = tree.rootKey().key ("Machine");
+        Key extraDataNode = machineNode.findKey ("ExtraData");
+
+        if (!extraDataNode.isNull())
+        {
+            /* check if the key exists */
+            Key::List items = extraDataNode.keys ("ExtraDataItem");
+            for (Key::List::const_iterator it = items.begin();
+                 it != items.end(); ++ it)
             {
-                found = true;
-                CFGLDRQueryBSTR(extraDataItemNode, "value", aValue);
+                if (key == (*it).stringValue ("name"))
+                {
+                    Bstr val = (*it).stringValue ("value");
+                    val.cloneTo (aValue);
+                    break;
+                }
             }
-            CFGLDRReleaseNode(extraDataItemNode);
-        }
-
-        CFGLDRReleaseNode(extraDataNode);
-        CFGLDRReleaseNode(machineNode);
-    }
-
-    rc = closeConfigLoader (configLoader, false /* aSaveBeforeClose */);
+        }
+    }
+    catch (...)
+    {
+        rc = VirtualBox::handleUnexpectedExceptions (RT_SRC_POS);
+    }
 
     return rc;
@@ -2085 +2099 @@
 
 /**
- *  @note Locks mParent for reading + this object for writing.
+ *  @note Locks mParent for writing + this object for writing.
  */
 STDMETHODIMP Machine::SetExtraData (INPTR BSTR aKey, INPTR BSTR aValue)
@@ -2095 +2109 @@
     CheckComRCReturnRC (autoCaller.rc());
 
-    /* VirtualBox::onExtraDataCanChange() needs mParent lock */
-    AutoMultiLock <2> alock (mParent->rlock(), this->wlock());
+    /* VirtualBox::onExtraDataCanChange() and saveSettings() need mParent
+     * lock (saveSettings() needs a write one) */
+    AutoMultiLock <2> alock (mParent->wlock(), this->wlock());
 
     if (mType == IsSnapshotMachine)
@@ -2107 +2122 @@
     HRESULT rc = S_OK;
 
-    /*
-     *  if we're ready and isConfigLocked() is FALSE then it means
-     *  that no config file exists yet, so call saveSettings() to create one
-     */
+    /* If we're ready and isConfigLocked() is FALSE then it means that no
+     * config file exists yet, so call saveSettings() to create one. */
     if (!isConfigLocked())
     {
         rc = saveSettings (false /* aMarkCurStateAsModified */);
-        if (FAILED (rc))
-            return rc;
-    }
-
-    /* load the config file */
-    CFGHANDLE configLoader = 0;
-    rc = openConfigLoader (&configLoader);
-    if (FAILED (rc))
-        return rc;
-
-    CFGNODE machineNode = 0;
-    CFGNODE extraDataNode = 0;
-
-    int vrc = CFGLDRGetNode (configLoader, "VirtualBox/Machine", 0, &machineNode);
-    if (VBOX_FAILURE (vrc))
-        vrc = CFGLDRCreateNode (configLoader, "VirtualBox/Machine", &machineNode);
-
-    vrc = CFGLDRGetChildNode (machineNode, "ExtraData", 0, &extraDataNode);
-    if (VBOX_FAILURE (vrc) && aValue)
-        vrc = CFGLDRCreateChildNode (machineNode, "ExtraData", &extraDataNode);
-
-    if (extraDataNode)
-    {
-        CFGNODE extraDataItemNode = 0;
+        CheckComRCReturnRC (rc);
+    }
+
+    try
+    {
+        using namespace settings;
+
+        /* load the config file */
+        File file (File::ReadWrite, mData->mHandleCfgFile,
+                   Utf8Str (mData->mConfigFileFull));
+        XmlTreeBackend tree;
+
+        rc = VirtualBox::loadSettingsTree_ForUpdate (tree, file);
+        CheckComRCReturnRC (rc);
+
+        const Utf8Str key = aKey;
         Bstr oldVal;
 
-        unsigned count;
-        CFGLDRCountChildren (extraDataNode, "ExtraDataItem", &count);
-
-        for (unsigned i = 0; i < count; i++)
-        {
-            CFGLDRGetChildNode (extraDataNode, "ExtraDataItem", i, &extraDataItemNode);
-            Bstr name;
-            CFGLDRQueryBSTR (extraDataItemNode, "name", name.asOutParam());
-            if (name == aKey)
+        Key machineNode = tree.rootKey().key ("Machine");
+        Key extraDataNode = machineNode.createKey ("ExtraData");
+        Key extraDataItemNode;
+
+        Key::List items = extraDataNode.keys ("ExtraDataItem");
+        for (Key::List::const_iterator it = items.begin();
+             it != items.end(); ++ it)
+        {
+            if (key == (*it).stringValue ("name"))
             {
-                CFGLDRQueryBSTR (extraDataItemNode, "value", oldVal.asOutParam());
+                extraDataItemNode = *it;
+                oldVal = (*it).stringValue ("value");
                 break;
             }
-            CFGLDRReleaseNode (extraDataItemNode);
-            extraDataItemNode = 0;
-        }
-
-        /*
-         *  When no key is found, oldVal is null
-         *  Note:
-         *  1. when oldVal is null, |oldVal == (BSTR) NULL| is true
-         *  2. we cannot do |oldVal != aValue| because it will compare
-         *  BSTR pointers instead of strings (due to type conversion ops)
-         */
-        changed = !(oldVal == aValue);
+        }
+
+        /* When no key is found, oldVal is null */
+        changed = oldVal != aValue;
 
         if (changed)
@@ -2176 +2174 @@
                 LogWarningFunc (("Someone vetoed! Change refused%s%ls\n",
                                  sep, err));
-                rc = setError (E_ACCESSDENIED,
+                return setError (E_ACCESSDENIED,
                     tr ("Could not set extra data because someone refused "
                         "the requested change of '%ls' to '%ls'%s%ls"),
                     aKey, aValue, sep, err);
             }
+
+            if (aValue != NULL)
+            {
+                if (extraDataItemNode.isNull())
+                {
+                    extraDataItemNode = extraDataNode.appendKey ("ExtraDataItem");
+                    extraDataItemNode.setStringValue ("name", key);
+                }
+                extraDataItemNode.setStringValue ("value", Utf8Str (aValue));
+            }
             else
             {
-                if (aValue)
-                {
-                    if (!extraDataItemNode)
-                    {
-                        /* create a new item */
-                        CFGLDRAppendChildNode (extraDataNode, "ExtraDataItem",
-                                               &extraDataItemNode);
-                        CFGLDRSetBSTR (extraDataItemNode, "name", aKey);
-                    }
-                    CFGLDRSetBSTR (extraDataItemNode, "value", aValue);
-                }
-                else
-                {
-                    /* an old value does for sure exist here */
-                    CFGLDRDeleteNode (extraDataItemNode);
-                    extraDataItemNode = 0;
-                }
+                /* an old value does for sure exist here (XML schema
+                 * guarantees that "value" may not absent in the
+                 * <ExtraDataItem> element) */
+                Assert (!extraDataItemNode.isNull());
+                extraDataItemNode.zap();
             }
-        }
-
-        if (extraDataItemNode)
-            CFGLDRReleaseNode (extraDataItemNode);
-
-        CFGLDRReleaseNode (extraDataNode);
-    }
-
-    CFGLDRReleaseNode (machineNode);
-
+
+            /* save settings on success */
+            rc = VirtualBox::saveSettingsTree (tree, file);
+            CheckComRCReturnRC (rc);
+        }
+    }
+    catch (...)
+    {
+        rc = VirtualBox::handleUnexpectedExceptions (RT_SRC_POS);
+    }
+
+    /* fire a notification */
     if (SUCCEEDED (rc) && changed)
-        rc = closeConfigLoader (configLoader, true /* aSaveBeforeClose */);
-    else
-        closeConfigLoader (configLoader, false /* aSaveBeforeClose */);
-
-    /* fire an event */
-    if (SUCCEEDED (rc) && changed)
-    {
         mParent->onExtraDataChange (mData->mUuid, aKey, aValue);
-    }
 
     return rc;
@@ -2230 +2220 @@
     CheckComRCReturnRC (autoCaller.rc());
 
-    /* Under some circumstancies, saveSettings() needs mParent lock */
+    /* saveSettings() needs mParent lock */
     AutoMultiLock <2> alock (mParent->wlock(), this->wlock());
 
@@ -2323 +2313 @@
         /* delete the directory that contains the settings file, but only
          * if it matches the VM name (i.e. a structure created by default in
-         * openConfigLoader()) */
+         * prepareSaveSettings()) */
         {
             Utf8Str settingsDir;
@@ -2545 +2535 @@
  *  @note locks this object for reading.
  */
-HRESULT Machine::saveRegistryEntry (CFGNODE aEntryNode)
-{
-    AssertReturn (aEntryNode, E_FAIL);
+HRESULT Machine::saveRegistryEntry (settings::Key &aEntryNode)
+{
+    AssertReturn (!aEntryNode.isNull(), E_FAIL);
 
     AutoLimitedCaller autoCaller (this);
@@ -2555 +2545 @@
 
     /* UUID */
-    CFGLDRSetUUID (aEntryNode, "uuid", mData->mUuid.raw());
+    aEntryNode.setValue <Guid> ("uuid", mData->mUuid);
     /* settings file name (possibly, relative) */
-    CFGLDRSetBSTR (aEntryNode, "src", mData->mConfigFile);
+    aEntryNode.setValue <Bstr> ("src", mData->mConfigFile);
 
     return S_OK;
@@ -3290 +3280 @@
  *  on the current thread because this will block Machine::uninit().
  *
- *  @note Locks this object and children for writing!
+ *  @note Must be called from mParent's write lock. Locks this object and
+ *  children for writing.
  */
 HRESULT Machine::trySetRegistered (BOOL aRegistered)
 {
+    AssertReturn (mParent->isLockedOnCurrentThread(), E_FAIL);
+
     AutoLimitedCaller autoCaller (this);
     AssertComRCReturnRC (autoCaller.rc());
@@ -3783 +3776 @@
         mData->mMachineState = aMachineState;
 
-        RTTIMESPEC time;
-        mData->mLastStateChange = RTTimeSpecGetMilli(RTTimeNow(&time));
+        RTTimeNow (&mData->mLastStateChange);
 
         mParent->onMachineStateChange (mData->mUuid, aMachineState);
@@ -3851 +3843 @@
     HRESULT rc = S_OK;
 
-    CFGHANDLE configLoader = NULL;
-    char *loaderError = NULL;
-    int vrc = CFGLDRLoad (&configLoader,
-                          Utf8Str (mData->mConfigFileFull), mData->mHandleCfgFile,
-                          XmlSchemaNS, true, cfgLdrEntityResolver,
-                          &loaderError);
-    if (VBOX_FAILURE (vrc))
-    {
-        rc = setError (E_FAIL,
-            tr ("Could not load the settings file '%ls' (%Vrc)%s%s"),
-            mData->mConfigFileFull.raw(), vrc,
-            loaderError ? ".\n" : "", loaderError ? loaderError : "");
-
-        if (loaderError)
-            RTMemTmpFree (loaderError);
-
-        LogFlowThisFuncLeave();
-        return rc;
-    }
-
-    /*
-     *  When reading the XML, we assume it has been validated, so we don't
-     *  do any structural checks here, Just Assert() some things.
-     */
-
-    CFGNODE machineNode = 0;
-    CFGLDRGetNode (configLoader, "VirtualBox/Machine", 0, &machineNode);
-
-    do
-    {
-        ComAssertBreak (machineNode, rc = E_FAIL);
+    try
+    {
+        using namespace settings;
+
+        File file (File::Read, mData->mHandleCfgFile,
+                   Utf8Str (mData->mConfigFileFull));
+        XmlTreeBackend tree;
+
+        rc = VirtualBox::loadSettingsTree_FirstTime (tree, file);
+        CheckComRCThrowRC (rc);
+
+        Key machineNode = tree.rootKey().key ("Machine");
 
         /* uuid (required) */
-        Guid id;
-        CFGLDRQueryUUID (machineNode, "uuid", id.ptr());
+        Guid id = machineNode.value <Guid> ("uuid");
 
         /* If the stored UUID is not empty, it means the registered machine
@@ -3894 +3866 @@
             if (mData->mUuid != id)
             {
-                rc = setError (E_FAIL,
+                throw setError (E_FAIL,
                     tr ("Machine UUID {%Vuuid} in '%ls' doesn't match its "
                         "UUID {%s} in the registry file '%ls'"),
@@ -3900 +3872 @@
                     mData->mUuid.toString().raw(),
                     mParent->settingsFileName().raw());
-                break;
             }
         }
@@ -3907 +3878 @@
 
         /* name (required) */
-        CFGLDRQueryBSTR (machineNode, "name", mUserData->mName.asOutParam());
+        mUserData->mName = machineNode.stringValue ("name");
 
         /* nameSync (optional, default is true) */
-        {
-            bool nameSync = true;
-            CFGLDRQueryBool (machineNode, "nameSync", &nameSync);
-            mUserData->mNameSync = nameSync;
-        }
+        mUserData->mNameSync = machineNode.value <bool> ("nameSync");
 
         /* Description (optional, default is null) */
         {
-            CFGNODE descNode = 0;
-            CFGLDRGetChildNode (machineNode, "Description", 0, &descNode);
-            if (descNode)
-            {
-                CFGLDRQueryBSTR (descNode, NULL,
-                                 mUserData->mDescription.asOutParam());
-                CFGLDRReleaseNode (descNode);
-            }
+            Key descNode = machineNode.findKey ("Description");
+            if (!descNode.isNull())
+                mUserData->mDescription = descNode.keyStringValue();
             else
                 mUserData->mDescription.setNull();
@@ -3932 +3894 @@
         /* OSType (required) */
         {
-            CFGLDRQueryBSTR (machineNode, "OSType",
-                             mUserData->mOSTypeId.asOutParam());
+            mUserData->mOSTypeId = machineNode.stringValue ("OSType");
 
             /* look up the object by Id to check it is valid */
@@ -3939 +3900 @@
             rc = mParent->GetGuestOSType (mUserData->mOSTypeId,
                                           guestOSType.asOutParam());
-            if (FAILED (rc))
-                break;
+            CheckComRCThrowRC (rc);
         }
 
         /* stateFile (optional) */
         {
-            Bstr stateFilePath;
-            CFGLDRQueryBSTR (machineNode, "stateFile", stateFilePath.asOutParam());
+            Bstr stateFilePath = machineNode.stringValue ("stateFile");
             if (stateFilePath)
             {
@@ -3953 +3912 @@
                 if (VBOX_FAILURE (vrc))
                 {
-                    rc = setError (E_FAIL,
+                    throw setError (E_FAIL,
                         tr ("Invalid saved state file path: '%ls' (%Vrc)"),
                         stateFilePath.raw(), vrc);
-                    break;
                 }
                 mSSData->mStateFilePath = stateFilePathFull;
@@ -3966 +3924 @@
         /*
          *  currentSnapshot ID (optional)
-         *  Note that due to XML Schema constaraints this attribute, when present,
-         *  will guaranteedly refer to an existing snapshot definition in XML
+         *
+         *  Note that due to XML Schema constaraints, this attribute, when
+         *  present, will guaranteedly refer to an existing snapshot
+         *  definition in XML
          */
-        Guid currentSnapshotId;
-        CFGLDRQueryUUID (machineNode, "currentSnapshot", currentSnapshotId.ptr());
+        Guid currentSnapshotId = machineNode.valueOr <Guid> ("currentSnapshot",
+                                                             Guid());
 
         /* snapshotFolder (optional) */
         {
-            Bstr folder;
-            CFGLDRQueryBSTR (machineNode, "snapshotFolder", folder.asOutParam());
+            Bstr folder = machineNode.stringValue ("snapshotFolder");
             rc = COMSETTER(SnapshotFolder) (folder);
-            if (FAILED (rc))
-                break;
-        }
+            CheckComRCThrowRC (rc);
+        }
+
+        /* currentStateModified (optional, default is true) */
+        mData->mCurrentStateModified = machineNode.value <bool> ("currentStateModified");
 
         /* lastStateChange (optional, for compatiblity) */
         {
-            int64_t lastStateChange = 0;
-            CFGLDRQueryDateTime (machineNode, "lastStateChange", &lastStateChange);
-            if (lastStateChange == 0)
-            {
-                /// @todo (dmik) until lastStateChange is the required attribute,
-                //  we simply set it to the current time if missing in the config
-                RTTIMESPEC time;
-                lastStateChange = RTTimeSpecGetMilli (RTTimeNow (&time));
-            }
-            mData->mLastStateChange = lastStateChange;
-        }
-
-        /* aborted (optional) */
-        bool aborted = false;
-        CFGLDRQueryBool (machineNode, "aborted", &aborted);
-
-        /* currentStateModified (optional, default is true) */
-        mData->mCurrentStateModified = TRUE;
-        {
-            bool val = true;
-            CFGLDRQueryBool (machineNode, "currentStateModified", &val);
-            mData->mCurrentStateModified = val;
-        }
+            /// @todo (dmik) until lastStateChange is the required attribute,
+            //  we simply set it to the current time if missing in the config
+            RTTIMESPEC now;
+            RTTimeNow (&now);
+            mData->mLastStateChange =
+                machineNode.valueOr <RTTIMESPEC> ("lastStateChange", now);
+        }
+
+        /* aborted (optional, default is false) */
+        bool aborted = machineNode.value <bool> ("aborted");
 
         /*
@@ -4016 +3964 @@
         /* Snapshot node (optional) */
         {
-            CFGNODE snapshotNode = 0;
-            CFGLDRGetChildNode (machineNode, "Snapshot", 0, &snapshotNode);
-            if (snapshotNode)
+            Key snapshotNode = machineNode.findKey ("Snapshot");
+            if (!snapshotNode.isNull())
             {
                 /* read all snapshots recursively */
                 rc = loadSnapshot (snapshotNode, currentSnapshotId, NULL);
-                CFGLDRReleaseNode (snapshotNode);
-                if (FAILED (rc))
-                    break;
+                CheckComRCThrowRC (rc);
             }
         }
 
         /* Hardware node (required) */
-        {
-            CFGNODE hardwareNode = 0;
-            CFGLDRGetChildNode (machineNode, "Hardware", 0, &hardwareNode);
-            ComAssertBreak (hardwareNode, rc = E_FAIL);
-            rc = loadHardware (hardwareNode);
-            CFGLDRReleaseNode (hardwareNode);
-            if (FAILED (rc))
-                break;
-        }
+        rc = loadHardware (machineNode.key ("Hardware"));
+        CheckComRCThrowRC (rc);
 
         /* HardDiskAttachments node (required) */
-        {
-            CFGNODE hdasNode = 0;
-            CFGLDRGetChildNode (machineNode, "HardDiskAttachments", 0, &hdasNode);
-            ComAssertBreak (hdasNode, rc = E_FAIL);
-
-            rc = loadHardDisks (hdasNode, aRegistered);
-            CFGLDRReleaseNode (hdasNode);
-            if (FAILED (rc))
-                break;
-        }
+        rc = loadHardDisks (machineNode.key ("HardDiskAttachments"), aRegistered);
+        CheckComRCThrowRC (rc);
 
         /*
@@ -4073 +4003 @@
         }
     }
-    while (0);
-
-    if (machineNode)
-        CFGLDRReleaseNode (machineNode);
-
-    CFGLDRFree (configLoader);
+    catch (HRESULT err)
+    {
+        /* we assume that error info is set by the thrower */
+        rc = err;
+    }
+    catch (...)
+    {
+        rc = VirtualBox::handleUnexpectedExceptions (RT_SRC_POS);
+    }
 
     LogFlowThisFuncLeave();
@@ -4087 +4020 @@
  *  Recursively loads all snapshots starting from the given.
  *
- *  @param aNode            <Snapshot> node
- *  @param aCurSnapshotId   current snapshot ID from the settings file
- *  @param aParentSnapshot  parent snapshot
+ *  @param aNode            <Snapshot> node.
+ *  @param aCurSnapshotId   Current snapshot ID from the settings file.
+ *  @param aParentSnapshot  Parent snapshot.
  */
-HRESULT Machine::loadSnapshot (CFGNODE aNode, const Guid &aCurSnapshotId,
+HRESULT Machine::loadSnapshot (const settings::Key &aNode,
+                               const Guid &aCurSnapshotId,
                                Snapshot *aParentSnapshot)
 {
-    AssertReturn (aNode, E_INVALIDARG);
+    using namespace settings;
+
+    AssertReturn (!aNode.isNull(), E_INVALIDARG);
     AssertReturn (mType == IsMachine, E_FAIL);
 
-    // create a snapshot machine object
+    /* create a snapshot machine object */
     ComObjPtr <SnapshotMachine> snapshotMachine;
     snapshotMachine.createObject();
@@ -4103 +4039 @@
     HRESULT rc = S_OK;
 
-    Guid uuid; // required
-    CFGLDRQueryUUID (aNode, "uuid", uuid.ptr());
-
-    Bstr stateFilePath; // optional
-    CFGLDRQueryBSTR (aNode, "stateFile", stateFilePath.asOutParam());
-    if (stateFilePath)
-    {
-        Utf8Str stateFilePathFull = stateFilePath;
-        int vrc = calculateFullPath (stateFilePathFull, stateFilePathFull);
-        if (VBOX_FAILURE (vrc))
-            return setError (E_FAIL,
-                tr ("Invalid saved state file path: '%ls' (%Vrc)"),
-                stateFilePath.raw(), vrc);
-
-        stateFilePath = stateFilePathFull;
-    }
-
-    do
-    {
-        // Hardware node (required)
-        CFGNODE hardwareNode = 0;
-        CFGLDRGetChildNode (aNode, "Hardware", 0, &hardwareNode);
-        ComAssertBreak (hardwareNode, rc = E_FAIL);
-
-        do
-        {
-            // HardDiskAttachments node (required)
-            CFGNODE hdasNode = 0;
-            CFGLDRGetChildNode (aNode, "HardDiskAttachments", 0, &hdasNode);
-            ComAssertBreak (hdasNode, rc = E_FAIL);
-
-            // initialize the snapshot machine
-            rc = snapshotMachine->init (this, hardwareNode, hdasNode,
-                                        uuid, stateFilePath);
-
-            CFGLDRReleaseNode (hdasNode);
-        }
-        while (0);
-
-        CFGLDRReleaseNode (hardwareNode);
-    }
-    while (0);
-
-    if (FAILED (rc))
-        return rc;
-
-    // create a snapshot object
+    /* required */
+    Guid uuid = aNode.value <Guid> ("uuid");
+
+    {
+        /* optional */
+        Bstr stateFilePath = aNode.stringValue ("stateFile");
+        if (stateFilePath)
+        {
+            Utf8Str stateFilePathFull = stateFilePath;
+            int vrc = calculateFullPath (stateFilePathFull, stateFilePathFull);
+            if (VBOX_FAILURE (vrc))
+                return setError (E_FAIL,
+                                 tr ("Invalid saved state file path: '%ls' (%Vrc)"),
+                                 stateFilePath.raw(), vrc);
+
+            stateFilePath = stateFilePathFull;
+        }
+
+        /* Hardware node (required) */
+        Key hardwareNode = aNode.key ("Hardware");
+
+        /* HardDiskAttachments node (required) */
+        Key hdasNode = aNode.key ("HardDiskAttachments");
+
+        /* initialize the snapshot machine */
+        rc = snapshotMachine->init (this, hardwareNode, hdasNode,
+                                    uuid, stateFilePath);
+        CheckComRCReturnRC (rc);
+    }
+
+    /* create a snapshot object */
     ComObjPtr <Snapshot> snapshot;
     snapshot.createObject();
 
     {
-        Bstr name; // required
-        CFGLDRQueryBSTR (aNode, "name", name.asOutParam());
-
-        LONG64 timeStamp = 0; // required
-        CFGLDRQueryDateTime (aNode, "timeStamp", &timeStamp);
-
-        Bstr description; // optional
-        {
-            CFGNODE descNode = 0;
-            CFGLDRGetChildNode (aNode, "Description", 0, &descNode);
-            if (descNode)
-            {
-                CFGLDRQueryBSTR (descNode, NULL, description.asOutParam());
-                CFGLDRReleaseNode (descNode);
-            }
-        }
-
-        // initialize the snapshot
+        /* required */
+        Bstr name = aNode.stringValue ("name");
+
+        /* required */
+        RTTIMESPEC timeStamp = aNode.value <RTTIMESPEC> ("timeStamp");
+
+        /* optional */
+        Bstr description;
+        {
+            Key descNode = aNode.findKey ("Description");
+            if (!descNode.isNull())
+                description = descNode.keyStringValue();
+        }
+
+        /* initialize the snapshot */
         rc = snapshot->init (uuid, name, description, timeStamp,
                              snapshotMachine, aParentSnapshot);
-        if (FAILED (rc))
-            return rc;
-    }
-
-    // memorize the first snapshot if necessary
+        CheckComRCReturnRC (rc);
+    }
+
+    /* memorize the first snapshot if necessary */
     if (!mData->mFirstSnapshot)
         mData->mFirstSnapshot = snapshot;
 
-    // memorize the current snapshot when appropriate
+    /* memorize the current snapshot when appropriate */
     if (!mData->mCurrentSnapshot && snapshot->data().mId == aCurSnapshotId)
         mData->mCurrentSnapshot = snapshot;
 
-    // Snapshots node (optional)
-    {
-        CFGNODE snapshotsNode = 0;
-        CFGLDRGetChildNode (aNode, "Snapshots", 0, &snapshotsNode);
-        if (snapshotsNode)
-        {
-            unsigned cbDisks = 0;
-            CFGLDRCountChildren (snapshotsNode, "Snapshot", &cbDisks);
-            for (unsigned i = 0; i < cbDisks && SUCCEEDED (rc); i++)
+    /* Snapshots node (optional) */
+    {
+        Key snapshotsNode = aNode.findKey ("Snapshots");
+        if (!snapshotsNode.isNull())
+        {
+            Key::List children = snapshotsNode.keys ("Snapshot");
+            for (Key::List::const_iterator it = children.begin();
+                 it != children.end(); ++ it)
             {
-                CFGNODE snapshotNode;
-                CFGLDRGetChildNode (snapshotsNode, "Snapshot", i, &snapshotNode);
-                ComAssertBreak (snapshotNode, rc = E_FAIL);
-
-                rc = loadSnapshot (snapshotNode, aCurSnapshotId, snapshot);
-
-                CFGLDRReleaseNode (snapshotNode);
+                rc = loadSnapshot ((*it), aCurSnapshotId, snapshot);
+                CheckComRCBreakRC (rc);
             }
-
-            CFGLDRReleaseNode (snapshotsNode);
         }
     }
@@ -4213 +4121 @@
 
 /**
- *  @param aNode    <Hardware> node
+ *  @param aNode    <Hardware> node.
  */
-HRESULT Machine::loadHardware (CFGNODE aNode)
-{
-    AssertReturn (aNode, E_INVALIDARG);
+HRESULT Machine::loadHardware (const settings::Key &aNode)
+{
+    using namespace settings;
+
+    AssertReturn (!aNode.isNull(), E_INVALIDARG);
     AssertReturn (mType == IsMachine || mType == IsSnapshotMachine, E_FAIL);
+
+    HRESULT rc = S_OK;
 
     /* CPU node (currently not required) */
@@ -4225 +4137 @@
         mHWData->mHWVirtExEnabled = TriStateBool_Default;
 
-        CFGNODE cpuNode = 0;
-        CFGLDRGetChildNode (aNode, "CPU", 0, &cpuNode);
-        if (cpuNode)
-        {
-            CFGNODE hwVirtExNode = 0;
-            CFGLDRGetChildNode (cpuNode, "HardwareVirtEx", 0, &hwVirtExNode);
-            if (hwVirtExNode)
+        Key cpuNode = aNode.findKey ("CPU");
+        if (!cpuNode.isNull())
+        {
+            Key hwVirtExNode = cpuNode.key ("HardwareVirtEx");
+            if (!hwVirtExNode.isNull())
             {
-                Bstr hwVirtExEnabled;
-                CFGLDRQueryBSTR (hwVirtExNode, "enabled", hwVirtExEnabled.asOutParam());
-                if      (hwVirtExEnabled == L"false")
+                const char *enabled = hwVirtExNode.stringValue ("enabled");
+                if      (strcmp (enabled, "false") == 0)
                     mHWData->mHWVirtExEnabled = TriStateBool_False;
-                else if (hwVirtExEnabled == L"true")
+                else if (strcmp (enabled, "true") == 0)
                     mHWData->mHWVirtExEnabled = TriStateBool_True;
                 else
                     mHWData->mHWVirtExEnabled = TriStateBool_Default;
-                CFGLDRReleaseNode (hwVirtExNode);
             }
-            CFGLDRReleaseNode (cpuNode);
         }
     }
@@ -4249 +4156 @@
     /* Memory node (required) */
     {
-        CFGNODE memoryNode = 0;
-        CFGLDRGetChildNode (aNode, "Memory", 0, &memoryNode);
-        ComAssertRet (memoryNode, E_FAIL);
-
-        uint32_t RAMSize;
-        CFGLDRQueryUInt32 (memoryNode, "RAMSize", &RAMSize);
-        mHWData->mMemorySize = RAMSize;
-        CFGLDRReleaseNode (memoryNode);
+        Key memoryNode = aNode.key ("Memory");
+
+        mHWData->mMemorySize = memoryNode.value <ULONG> ("RAMSize");
     }
 
@@ -4265 +4167 @@
             mHWData->mBootOrder [i] = DeviceType_NoDevice;
 
-        CFGNODE bootNode = 0;
-        CFGLDRGetChildNode (aNode, "Boot", 0, &bootNode);
-        ComAssertRet (bootNode, E_FAIL);
-
-        HRESULT rc = S_OK;
-
-        unsigned cOrder;
-        CFGLDRCountChildren (bootNode, "Order", &cOrder);
-        for (unsigned i = 0; i < cOrder; i++)
-        {
-            CFGNODE orderNode = 0;
-            CFGLDRGetChildNode (bootNode, "Order", i, &orderNode);
-            ComAssertBreak (orderNode, rc = E_FAIL);
-
+        Key bootNode = aNode.key ("Boot");
+
+        Key::List orderNodes = bootNode.keys ("Order");
+        for (Key::List::const_iterator it = orderNodes.begin();
+             it != orderNodes.end(); ++ it)
+        {
             /* position (required) */
             /* position unicity is guaranteed by XML Schema */
-            uint32_t position = 0;
-            CFGLDRQueryUInt32 (orderNode, "position", &position);
+            uint32_t position = (*it).value <uint32_t> ("position");
             -- position;
             Assert (position < ELEMENTS (mHWData->mBootOrder));
 
             /* device (required) */
-            Bstr device;
-            CFGLDRQueryBSTR (orderNode, "device", device.asOutParam());
-            if      (device == L"None")
+            const char *device = (*it).stringValue ("device");
+            if      (strcmp (device, "None") == 0)
                 mHWData->mBootOrder [position] = DeviceType_NoDevice;
-            else if (device == L"Floppy")
+            else if (strcmp (device, "Floppy") == 0)
                 mHWData->mBootOrder [position] = DeviceType_FloppyDevice;
-            else if (device == L"DVD")
+            else if (strcmp (device, "DVD") == 0)
                 mHWData->mBootOrder [position] = DeviceType_DVDDevice;
-            else if (device == L"HardDisk")
+            else if (strcmp (device, "HardDisk") == 0)
                 mHWData->mBootOrder [position] = DeviceType_HardDiskDevice;
-            else if (device == L"Network")
+            else if (strcmp (device, "Network") == 0)
                 mHWData->mBootOrder [position] = DeviceType_NetworkDevice;
             else
-                ComAssertMsgFailed (("Invalid device: %ls\n", device.raw()));
-
-            CFGLDRReleaseNode (orderNode);
-        }
-
-        CFGLDRReleaseNode (bootNode);
-        if (FAILED (rc))
-            return rc;
+                ComAssertMsgFailed (("Invalid device: %s\n", device));
+        }
     }
 
     /* Display node (required) */
     {
-        CFGNODE displayNode = 0;
-        CFGLDRGetChildNode (aNode, "Display", 0, &displayNode);
-        ComAssertRet (displayNode, E_FAIL);
-
-        uint32_t VRAMSize;
-        CFGLDRQueryUInt32 (displayNode, "VRAMSize", &VRAMSize);
-        mHWData->mVRAMSize = VRAMSize;
-
-        uint32_t MonitorCount;
-        CFGLDRQueryUInt32 (displayNode, "MonitorCount", &MonitorCount);
-        mHWData->mMonitorCount = MonitorCount;
-
-        CFGLDRReleaseNode (displayNode);
+        Key displayNode = aNode.key ("Display");
+
+        mHWData->mVRAMSize = displayNode.value <ULONG> ("VRAMSize");
+        mHWData->mMonitorCount = displayNode.value <ULONG> ("MonitorCount");
     }
 
 #ifdef VBOX_VRDP
-    /* RemoteDisplay node (optional) */
-    {
-        CFGNODE remoteDisplayNode = 0;
-        CFGLDRGetChildNode (aNode, "RemoteDisplay", 0, &remoteDisplayNode);
-        if (remoteDisplayNode)
-        {
-            HRESULT rc = mVRDPServer->loadSettings (remoteDisplayNode);
-            CFGLDRReleaseNode (remoteDisplayNode);
-            CheckComRCReturnRC (rc);
-        }
-    }
+    /* RemoteDisplay */
+    rc = mVRDPServer->loadSettings (aNode);
+    CheckComRCReturnRC (rc);
 #endif
 
-    /* BIOS node (required) */
-    {
-        CFGNODE biosNode = 0;
-        CFGLDRGetChildNode (aNode, "BIOS", 0, &biosNode);
-        ComAssertRet (biosNode, E_FAIL);
-
-        HRESULT rc = S_OK;
-
-        do
-        {
-            /* ACPI */
-            {
-                CFGNODE acpiNode = 0;
-                CFGLDRGetChildNode (biosNode, "ACPI", 0, &acpiNode);
-                ComAssertBreak (acpiNode, rc = E_FAIL);
-
-                bool enabled;
-                CFGLDRQueryBool (acpiNode, "enabled", &enabled);
-                mBIOSSettings->COMSETTER(ACPIEnabled)(enabled);
-                CFGLDRReleaseNode (acpiNode);
-            }
-
-            /* IOAPIC */
-            {
-                CFGNODE ioapicNode = 0;
-                CFGLDRGetChildNode (biosNode, "IOAPIC", 0, &ioapicNode);
-                if (ioapicNode)
-                {
-                    bool enabled;
-                    CFGLDRQueryBool (ioapicNode, "enabled", &enabled);
-                    mBIOSSettings->COMSETTER(IOAPICEnabled)(enabled);
-                    CFGLDRReleaseNode (ioapicNode);
-                }
-            }
-
-            /* Logo (optional) */
-            {
-                CFGNODE logoNode = 0;
-                CFGLDRGetChildNode (biosNode, "Logo", 0, &logoNode);
-                if (logoNode)
-                {
-                    bool enabled = false;
-                    CFGLDRQueryBool (logoNode, "fadeIn", &enabled);
-                    mBIOSSettings->COMSETTER(LogoFadeIn)(enabled);
-                    CFGLDRQueryBool (logoNode, "fadeOut", &enabled);
-                    mBIOSSettings->COMSETTER(LogoFadeOut)(enabled);
-
-                    uint32_t BIOSLogoDisplayTime;
-                    CFGLDRQueryUInt32 (logoNode, "displayTime", &BIOSLogoDisplayTime);
-                    mBIOSSettings->COMSETTER(LogoDisplayTime)(BIOSLogoDisplayTime);
-
-                    Bstr logoPath;
-                    CFGLDRQueryBSTR (logoNode, "imagePath", logoPath.asOutParam());
-                    mBIOSSettings->COMSETTER(LogoImagePath)(logoPath);
-
-                    CFGLDRReleaseNode (logoNode);
-                }
-            }
-
-            /* boot menu (optional) */
-            {
-                CFGNODE bootMenuNode = 0;
-                CFGLDRGetChildNode (biosNode, "BootMenu", 0, &bootMenuNode);
-                if (bootMenuNode)
-                {
-                    Bstr modeStr;
-                    BIOSBootMenuMode_T mode;
-                    CFGLDRQueryBSTR (bootMenuNode, "mode", modeStr.asOutParam());
-                    if (modeStr == L"disabled")
-                        mode = BIOSBootMenuMode_Disabled;
-                    else if (modeStr == L"menuonly")
-                        mode = BIOSBootMenuMode_MenuOnly;
-                    else
-                        mode = BIOSBootMenuMode_MessageAndMenu;
-                    mBIOSSettings->COMSETTER(BootMenuMode)(mode);
-
-                    CFGLDRReleaseNode (bootMenuNode);
-                }
-            }
-
-            /* PXE debug logging (optional) */
-            {
-                CFGNODE pxedebugNode = 0;
-                CFGLDRGetChildNode (biosNode, "PXEDebug", 0, &pxedebugNode);
-                if (pxedebugNode)
-                {
-                    bool enabled;
-                    CFGLDRQueryBool (pxedebugNode, "enabled", &enabled);
-                    mBIOSSettings->COMSETTER(PXEDebugEnabled)(enabled);
-                    CFGLDRReleaseNode (pxedebugNode);
-                }
-            }
-
-            /* time offset (optional) */
-            {
-                CFGNODE timeOffsetNode = 0;
-                CFGLDRGetChildNode (biosNode, "TimeOffset", 0, &timeOffsetNode);
-                if (timeOffsetNode)
-                {
-                    LONG64 timeOffset;
-                    CFGLDRQueryInt64 (timeOffsetNode, "value", &timeOffset);
-                    mBIOSSettings->COMSETTER(TimeOffset)(timeOffset);
-                    CFGLDRReleaseNode (timeOffsetNode);
-                }
-            }
-
-            /* IDE controller type (optional, defaults to PIIX3) */
-            {
-                CFGNODE ideControllerNode = 0;
-                IDEControllerType_T controllerType = IDEControllerType_IDEControllerPIIX3;
-                CFGLDRGetChildNode (biosNode, "IDEController", 0, &ideControllerNode);
-                if (ideControllerNode)
-                {
-                    Bstr IDEControllerType;
-
-                    CFGLDRQueryBSTR (ideControllerNode, "type", IDEControllerType.asOutParam());
-                    ComAssertBreak (IDEControllerType, rc = E_FAIL);
-
-                    if (IDEControllerType.compare(Bstr("PIIX3")) == 0)
-                        controllerType = IDEControllerType_IDEControllerPIIX3;
-                    else if (IDEControllerType.compare(Bstr("PIIX4")) == 0)
-                        controllerType = IDEControllerType_IDEControllerPIIX4;
-                    else
-                        ComAssertBreak (0, rc = E_FAIL);
-
-                    CFGLDRReleaseNode (ideControllerNode);
-                }
-                mBIOSSettings->COMSETTER(IDEControllerType)(controllerType);
-            }
-
-        }
-        while (0);
-
-        CFGLDRReleaseNode (biosNode);
-        if (FAILED (rc))
-            return rc;
-    }
-
-    /* DVD drive (contains either Image or HostDrive or nothing) */
-    /// @todo (dmik) move the code to DVDDrive
-    {
-        HRESULT rc = S_OK;
-
-        CFGNODE dvdDriveNode = 0;
-        CFGLDRGetChildNode (aNode, "DVDDrive", 0, &dvdDriveNode);
-        ComAssertRet (dvdDriveNode, E_FAIL);
-
-        bool fPassthrough;
-        CFGLDRQueryBool(dvdDriveNode, "passthrough", &fPassthrough);
-        mDVDDrive->COMSETTER(Passthrough)(fPassthrough);
-
-        CFGNODE typeNode = 0;
-
-        do
-        {
-            CFGLDRGetChildNode (dvdDriveNode, "Image", 0, &typeNode);
-            if (typeNode)
-            {
-                Guid uuid;
-                CFGLDRQueryUUID (typeNode, "uuid", uuid.ptr());
-                rc = mDVDDrive->MountImage (uuid);
-            }
-            else
-            {
-                CFGLDRGetChildNode (dvdDriveNode, "HostDrive", 0, &typeNode);
-                if (typeNode)
-                {
-                    Bstr src;
-                    CFGLDRQueryBSTR (typeNode, "src", src.asOutParam());
-
-                    /* find the correspoding object */
-                    ComPtr <IHost> host;
-                    rc = mParent->COMGETTER(Host) (host.asOutParam());
-                    ComAssertComRCBreak (rc, rc = rc);
-
-                    ComPtr <IHostDVDDriveCollection> coll;
-                    rc = host->COMGETTER(DVDDrives) (coll.asOutParam());
-                    ComAssertComRCBreak (rc, rc = rc);
-
-                    ComPtr <IHostDVDDrive> drive;
-                    rc = coll->FindByName (src, drive.asOutParam());
-                    if (SUCCEEDED (rc))
-                        rc = mDVDDrive->CaptureHostDrive (drive);
-                    else if (rc == E_INVALIDARG)
-                    {
-                        /* the host DVD drive is not currently available. we
-                         * assume it will be available later and create an
-                         * extra object now */
-                        ComObjPtr <HostDVDDrive> hostDrive;
-                        hostDrive.createObject();
-                        rc = hostDrive->init (src);
-                        ComAssertComRCBreak (rc, rc = rc);
-                        rc = mDVDDrive->CaptureHostDrive (hostDrive);
-                    }
-                    else
-                        ComAssertComRCBreakRC (rc);
-                }
-            }
-        }
-        while (0);
-
-        if (typeNode)
-            CFGLDRReleaseNode (typeNode);
-        CFGLDRReleaseNode (dvdDriveNode);
-
-        if (FAILED (rc))
-            return rc;
-    }
-
-    /* Floppy drive (contains either Image or HostDrive or nothing) */
-    /// @todo (dmik) move the code to FloppyDrive
-    {
-        HRESULT rc = S_OK;
-
-        CFGNODE driveNode = 0;
-        CFGLDRGetChildNode (aNode, "FloppyDrive", 0, &driveNode);
-        ComAssertRet (driveNode, E_FAIL);
-
-        BOOL fFloppyEnabled = TRUE;
-        CFGLDRQueryBool (driveNode, "enabled", (bool*)&fFloppyEnabled);
-        rc = mFloppyDrive->COMSETTER(Enabled)(fFloppyEnabled);
-
-        CFGNODE typeNode = 0;
-        do
-        {
-            CFGLDRGetChildNode (driveNode, "Image", 0, &typeNode);
-            if (typeNode)
-            {
-                Guid uuid;
-                CFGLDRQueryUUID (typeNode, "uuid", uuid.ptr());
-                rc = mFloppyDrive->MountImage (uuid);
-            }
-            else
-            {
-                CFGLDRGetChildNode (driveNode, "HostDrive", 0, &typeNode);
-                if (typeNode)
-                {
-                    Bstr src;
-                    CFGLDRQueryBSTR (typeNode, "src", src.asOutParam());
-
-                    /* find the correspoding object */
-                    ComPtr <IHost> host;
-                    rc = mParent->COMGETTER(Host) (host.asOutParam());
-                    ComAssertComRCBreak (rc, rc = rc);
-
-                    ComPtr <IHostFloppyDriveCollection> coll;
-                    rc = host->COMGETTER(FloppyDrives) (coll.asOutParam());
-                    ComAssertComRCBreak (rc, rc = rc);
-
-                    ComPtr <IHostFloppyDrive> drive;
-                    rc = coll->FindByName (src, drive.asOutParam());
-                    if (SUCCEEDED (rc))
-                        rc = mFloppyDrive->CaptureHostDrive (drive);
-                    else if (rc == E_INVALIDARG)
-                    {
-                        /* the host Floppy drive is not currently available. we
-                         * assume it will be available later and create an
-                         * extra object now */
-                        ComObjPtr <HostFloppyDrive> hostDrive;
-                        hostDrive.createObject();
-                        rc = hostDrive->init (src);
-                        ComAssertComRCBreak (rc, rc = rc);
-                        rc = mFloppyDrive->CaptureHostDrive (hostDrive);
-                    }
-                    else
-                        ComAssertComRCBreakRC (rc);
-                }
-            }
-        }
-        while (0);
-
-        if (typeNode)
-            CFGLDRReleaseNode (typeNode);
-        CFGLDRReleaseNode (driveNode);
-
-        CheckComRCReturnRC (rc);
-    }
+    /* BIOS */
+    rc = mBIOSSettings->loadSettings (aNode);
+    CheckComRCReturnRC (rc);
+
+    /* DVD drive */
+    rc = mDVDDrive->loadSettings (aNode);
+    CheckComRCReturnRC (rc);
+
+    /* Floppy drive */
+    rc = mFloppyDrive->loadSettings (aNode);
+    CheckComRCReturnRC (rc);
 
     /* USB Controller */
-    {
-        HRESULT rc = mUSBController->loadSettings (aNode);
-        CheckComRCReturnRC (rc);
-    }
+    rc = mUSBController->loadSettings (aNode);
+    CheckComRCReturnRC (rc);
 
     /* Network node (required) */
-    /// @todo (dmik) move the code to NetworkAdapter
     {
         /* we assume that all network adapters are initially disabled
          * and detached */
 
-        CFGNODE networkNode = 0;
-        CFGLDRGetChildNode (aNode, "Network", 0, &networkNode);
-        ComAssertRet (networkNode, E_FAIL);
-
-        HRESULT rc = S_OK;
-
-        unsigned cAdapters = 0;
-        CFGLDRCountChildren (networkNode, "Adapter", &cAdapters);
-        for (unsigned i = 0; i < cAdapters; i++)
-        {
-            CFGNODE adapterNode = 0;
-            CFGLDRGetChildNode (networkNode, "Adapter", i, &adapterNode);
-            ComAssertBreak (adapterNode, rc = E_FAIL);
-
+        Key networkNode = aNode.key ("Network");
+
+        rc = S_OK;
+
+        Key::List adapters = networkNode.keys ("Adapter");
+        for (Key::List::const_iterator it = adapters.begin();
+             it != adapters.end(); ++ it)
+        {
             /* slot number (required) */
             /* slot unicity is guaranteed by XML Schema */
-            uint32_t slot = 0;
-            CFGLDRQueryUInt32 (adapterNode, "slot", &slot);
-            Assert (slot < ELEMENTS (mNetworkAdapters));
-
-            /* type */
-            Bstr adapterType;
-            CFGLDRQueryBSTR (adapterNode, "type", adapterType.asOutParam());
-            ComAssertBreak (adapterType, rc = E_FAIL);
-
-            /* enabled (required) */
-            bool enabled = false;
-            CFGLDRQueryBool (adapterNode, "enabled", &enabled);
-            /* MAC address (can be null) */
-            Bstr macAddr;
-            CFGLDRQueryBSTR (adapterNode, "MACAddress", macAddr.asOutParam());
-            /* cable (required) */
-            bool cableConnected;
-            CFGLDRQueryBool (adapterNode, "cable", &cableConnected);
-            /* line speed (defaults to 100 Mbps) */
-            uint32_t lineSpeed = 100000;
-            CFGLDRQueryUInt32 (adapterNode, "speed", &lineSpeed);
-            /* tracing (defaults to false) */
-            bool traceEnabled;
-            CFGLDRQueryBool (adapterNode, "trace", &traceEnabled);
-            Bstr traceFile;
-            CFGLDRQueryBSTR (adapterNode, "tracefile", traceFile.asOutParam());
-
-            rc = mNetworkAdapters [slot]->COMSETTER(Enabled) (enabled);
-            CheckComRCBreakRC (rc);
-            rc = mNetworkAdapters [slot]->COMSETTER(MACAddress) (macAddr);
-            CheckComRCBreakRC (rc);
-            rc = mNetworkAdapters [slot]->COMSETTER(CableConnected) (cableConnected);
-            CheckComRCBreakRC (rc);
-            rc = mNetworkAdapters [slot]->COMSETTER(LineSpeed) (lineSpeed);
-            CheckComRCBreakRC (rc);
-            rc = mNetworkAdapters [slot]->COMSETTER(TraceEnabled) (traceEnabled);
-            CheckComRCBreakRC (rc);
-            rc = mNetworkAdapters [slot]->COMSETTER(TraceFile) (traceFile);
-            CheckComRCBreakRC (rc);
-
-            if (adapterType.compare(Bstr("Am79C970A")) == 0)
-                mNetworkAdapters [slot]->COMSETTER(AdapterType)(NetworkAdapterType_NetworkAdapterAm79C970A);
-            else if (adapterType.compare(Bstr("Am79C973")) == 0)
-                mNetworkAdapters [slot]->COMSETTER(AdapterType)(NetworkAdapterType_NetworkAdapterAm79C973);
-#ifdef VBOX_WITH_E1000
-            else if (adapterType.compare(Bstr("82540EM")) == 0)
-                mNetworkAdapters [slot]->COMSETTER(AdapterType)(NetworkAdapterType_NetworkAdapter82540EM);
-#endif
-            else
-                ComAssertBreak (0, rc = E_FAIL);
-
-            CFGNODE attachmentNode = 0;
-            if (CFGLDRGetChildNode (adapterNode, "NAT", 0, &attachmentNode), attachmentNode)
+            uint32_t slot = (*it).value <uint32_t> ("slot");
+            AssertBreakVoid (slot < ELEMENTS (mNetworkAdapters));
+
+            rc = mNetworkAdapters [slot]->loadSettings (*it);
+            CheckComRCReturnRC (rc);
+        }
+    }
+
+    /* Serial node (optional) */
+    {
+        Key serialNode = aNode.findKey ("Uart");
+        if (!serialNode.isNull())
+        {
+            rc = S_OK;
+
+            Key::List ports = serialNode.keys ("Port");
+            for (Key::List::const_iterator it = ports.begin();
+                 it != ports.end(); ++ it)
             {
-                rc = mNetworkAdapters [slot]->AttachToNAT();
-                CheckComRCBreakRC (rc);
+                /* slot number (required) */
+                /* slot unicity is guaranteed by XML Schema */
+                uint32_t slot = (*it).value <uint32_t> ("slot");
+                AssertBreakVoid (slot < ELEMENTS (mSerialPorts));
+
+                rc = mSerialPorts [slot]->loadSettings (*it);
+                CheckComRCReturnRC (rc);
             }
-            else
-            if (CFGLDRGetChildNode (adapterNode, "HostInterface", 0, &attachmentNode), attachmentNode)
+        }
+    }
+
+    /* Parallel node (optional) */
+    {
+        Key parallelNode = aNode.findKey ("Lpt");
+        if (!parallelNode.isNull())
+        {
+            rc = S_OK;
+
+            Key::List ports = parallelNode.keys ("Port");
+            for (Key::List::const_iterator it = ports.begin();
+                 it != ports.end(); ++ it)
             {
-                /* Host Interface Networking */
-                Bstr name;
-                CFGLDRQueryBSTR (attachmentNode, "name", name.asOutParam());
-#ifdef RT_OS_WINDOWS
-                /* @name can be empty on Win32, but not null */
-                ComAssertBreak (!name.isNull(), rc = E_FAIL);
-#endif
-                rc = mNetworkAdapters [slot]->COMSETTER(HostInterface) (name);
-                CheckComRCBreakRC (rc);
-#ifdef VBOX_WITH_UNIXY_TAP_NETWORKING
-                Bstr tapSetupApp;
-                CFGLDRQueryBSTR (attachmentNode, "TAPSetup", tapSetupApp.asOutParam());
-                Bstr tapTerminateApp;
-                CFGLDRQueryBSTR (attachmentNode, "TAPTerminate", tapTerminateApp.asOutParam());
-
-                rc = mNetworkAdapters [slot]->COMSETTER(TAPSetupApplication) (tapSetupApp);
-                CheckComRCBreakRC (rc);
-                rc = mNetworkAdapters [slot]->COMSETTER(TAPTerminateApplication) (tapTerminateApp);
-                CheckComRCBreakRC (rc);
-#endif // VBOX_WITH_UNIXY_TAP_NETWORKING
-                rc = mNetworkAdapters [slot]->AttachToHostInterface();
-                CheckComRCBreakRC (rc);
+                /* slot number (required) */
+                /* slot unicity is guaranteed by XML Schema */
+                uint32_t slot = (*it).value <uint32_t> ("slot");
+                AssertBreakVoid (slot < ELEMENTS (mSerialPorts));
+
+                rc = mParallelPorts [slot]->loadSettings (*it);
+                CheckComRCReturnRC (rc);
             }
-            else
-            if (CFGLDRGetChildNode(adapterNode, "InternalNetwork", 0, &attachmentNode), attachmentNode)
-            {
-                /* Internal Networking */
-                Bstr name;
-                CFGLDRQueryBSTR (attachmentNode, "name", name.asOutParam());
-                ComAssertBreak (!name.isNull(), rc = E_FAIL);
-                rc = mNetworkAdapters[slot]->AttachToInternalNetwork();
-                CheckComRCBreakRC (rc);
-                rc = mNetworkAdapters[slot]->COMSETTER(InternalNetwork) (name);
-                CheckComRCBreakRC (rc);
-            }
-            else
-            {
-                /* Adapter has no children */
-                rc = mNetworkAdapters [slot]->Detach();
-                CheckComRCBreakRC (rc);
-            }
-            if (attachmentNode)
-                CFGLDRReleaseNode (attachmentNode);
-
-            CFGLDRReleaseNode (adapterNode);
-        }
-
-        CFGLDRReleaseNode (networkNode);
-        CheckComRCReturnRC (rc);
-    }
-
-    /* Serial node (optional) */
-    CFGNODE serialNode = 0;
-    CFGLDRGetChildNode (aNode, "Uart", 0, &serialNode);
-    if (serialNode)
-    {
-        HRESULT rc = S_OK;
-        unsigned cPorts = 0;
-        CFGLDRCountChildren (serialNode, "Port", &cPorts);
-        for (unsigned slot = 0; slot < cPorts; slot++)
-        {
-            rc = mSerialPorts [slot]->loadSettings (serialNode, slot);
-            CheckComRCBreakRC (rc);
-        }
-
-        CFGLDRReleaseNode (serialNode);
-        CheckComRCReturnRC (rc);
-    }
-
-    /* Parallel node (optional) */
-    CFGNODE parallelNode = 0;
-    CFGLDRGetChildNode (aNode, "Lpt", 0, &parallelNode);
-    if (parallelNode)
-    {
-        HRESULT rc = S_OK;
-        unsigned cPorts = 0;
-        CFGLDRCountChildren (parallelNode, "Port", &cPorts);
-        for (unsigned slot = 0; slot < cPorts; slot++)
-        {
-            rc = mParallelPorts [slot]->loadSettings (parallelNode, slot);
-            CheckComRCBreakRC (rc);
-        }
-
-        CFGLDRReleaseNode (parallelNode);
-        CheckComRCReturnRC (rc);
-    }
-
-    /* AudioAdapter node (required) */
-    /// @todo (dmik) move the code to AudioAdapter
-    {
-        CFGNODE audioAdapterNode = 0;
-        CFGLDRGetChildNode (aNode, "AudioAdapter", 0, &audioAdapterNode);
-        ComAssertRet (audioAdapterNode, E_FAIL);
-
-        /* is the adapter enabled? */
-        bool enabled = false;
-        CFGLDRQueryBool (audioAdapterNode, "enabled", &enabled);
-        mAudioAdapter->COMSETTER(Enabled) (enabled);
-        /* now check the audio driver */
-        Bstr driver;
-        CFGLDRQueryBSTR (audioAdapterNode, "driver", driver.asOutParam());
-        AudioDriverType_T audioDriver;
-        audioDriver = AudioDriverType_NullAudioDriver;
-        if      (driver == L"null")
-            ; /* Null has been set above */
-#ifdef RT_OS_WINDOWS
-        else if (driver == L"winmm")
-#ifdef VBOX_WITH_WINMM
-            audioDriver = AudioDriverType_WINMMAudioDriver;
-#else
-        /* fall back to dsound */
-            audioDriver = AudioDriverType_DSOUNDAudioDriver;
-#endif
-        else if (driver == L"dsound")
-            audioDriver = AudioDriverType_DSOUNDAudioDriver;
-#endif // RT_OS_WINDOWS
-#ifdef RT_OS_LINUX
-        else if (driver == L"oss")
-            audioDriver = AudioDriverType_OSSAudioDriver;
-        else if (driver == L"alsa")
-# ifdef VBOX_WITH_ALSA
-            audioDriver = AudioDriverType_ALSAAudioDriver;
-# else
-            /* fall back to OSS */
-            audioDriver = AudioDriverType_OSSAudioDriver;
-# endif
-        else if (driver == L"pulse")
-# ifdef VBOX_WITH_PULSE
-            audioDriver = AudioDriverType_PulseAudioDriver;
-# else
-            /* fall back to OSS */
-            audioDriver = AudioDriverType_OSSAudioDriver;
-# endif
-#endif // RT_OS_LINUX
-#ifdef RT_OS_DARWIN
-        else if (driver == L"coreaudio")
-            audioDriver = AudioDriverType_CoreAudioDriver;
-#endif
-#ifdef RT_OS_OS2
-        else if (driver == L"mmpm")
-            audioDriver = AudioDriverType_MMPMAudioDriver;
-#endif
-        else
-            AssertMsgFailed (("Invalid driver: %ls\n", driver.raw()));
-
-        HRESULT rc = mAudioAdapter->COMSETTER(AudioDriver) (audioDriver);
-
-        CFGLDRReleaseNode (audioAdapterNode);
-        CheckComRCReturnRC (rc);
-    }
+        }
+    }
+
+    /* AudioAdapter */
+    rc = mAudioAdapter->loadSettings (aNode);
+    CheckComRCReturnRC (rc);
 
     /* Shared folders (optional) */
     /// @todo (dmik) make required on next format change!
-    do
-    {
-        CFGNODE sharedFoldersNode = 0;
-        CFGLDRGetChildNode (aNode, "SharedFolders", 0, &sharedFoldersNode);
-
-        if (!sharedFoldersNode)
-            break;
-
-        HRESULT rc = S_OK;
-
-        unsigned cFolders = 0;
-        CFGLDRCountChildren (sharedFoldersNode, "SharedFolder", &cFolders);
-
-        for (unsigned i = 0; i < cFolders; i++)
-        {
-            CFGNODE folderNode = 0;
-            CFGLDRGetChildNode (sharedFoldersNode, "SharedFolder", i, &folderNode);
-            ComAssertBreak (folderNode, rc = E_FAIL);
-
-            // folder logical name (required)
-            Bstr name;
-            CFGLDRQueryBSTR (folderNode, "name", name.asOutParam());
-
-            // folder host path (required)
-            Bstr hostPath;
-            CFGLDRQueryBSTR (folderNode, "hostPath", hostPath.asOutParam());
-
-            rc = CreateSharedFolder (name, hostPath);
-            CheckComRCBreakRC (rc);
-
-            CFGLDRReleaseNode (folderNode);
-        }
-
-        CFGLDRReleaseNode (sharedFoldersNode);
-        CheckComRCReturnRC (rc);
-    }
-    while (0);
+    {
+        Key sharedFoldersNode = aNode.findKey ("SharedFolders");
+        if (!sharedFoldersNode.isNull())
+        {
+            rc = S_OK;
+
+            Key::List folders = sharedFoldersNode.keys ("SharedFolder");
+            for (Key::List::const_iterator it = folders.begin();
+                 it != folders.end(); ++ it)
+            {
+                /* folder logical name (required) */
+                Bstr name = (*it).stringValue ("name");
+                /* folder host path (required) */
+                Bstr hostPath = (*it).stringValue ("hostPath");
+
+                rc = CreateSharedFolder (name, hostPath);
+                CheckComRCReturnRC (rc);
+            }
+        }
+    }
 
     /* Clipboard node (currently not required) */
     /// @todo (dmik) make required on next format change!
     {
-        /* default value in case the node is not there */
+        /* default value in case if the node is not there */
         mHWData->mClipboardMode = ClipboardMode_ClipDisabled;
 
-        CFGNODE clipNode = 0;
-        CFGLDRGetChildNode (aNode, "Clipboard", 0, &clipNode);
-        if (clipNode)
-        {
-            Bstr mode;
-            CFGLDRQueryBSTR (clipNode, "mode", mode.asOutParam());
-            if      (mode == L"Disabled")
+        Key clipNode = aNode.findKey ("Clipboard");
+        if (!clipNode.isNull())
+        {
+            const char *mode = clipNode.stringValue ("mode");
+            if      (strcmp (mode, "Disabled") == 0)
                 mHWData->mClipboardMode = ClipboardMode_ClipDisabled;
-            else if (mode == L"HostToGuest")
+            else if (strcmp (mode, "HostToGuest") == 0)
                 mHWData->mClipboardMode = ClipboardMode_ClipHostToGuest;
-            else if (mode == L"GuestToHost")
+            else if (strcmp (mode, "GuestToHost") == 0)
                 mHWData->mClipboardMode = ClipboardMode_ClipGuestToHost;
-            else if (mode == L"Bidirectional")
+            else if (strcmp (mode, "Bidirectional") == 0)
                 mHWData->mClipboardMode = ClipboardMode_ClipBidirectional;
             else
-                AssertMsgFailed (("%ls clipboard mode is invalid\n", mode.raw()));
-            CFGLDRReleaseNode (clipNode);
+                AssertMsgFailed (("Invalid clipboard mode '%s'\n", mode));
         }
     }
 
     /* Guest node (optional) */
-    /// @todo (dmik) make required on next format change!
-    {
-        CFGNODE guestNode = 0;
-        CFGLDRGetChildNode (aNode, "Guest", 0, &guestNode);
-        if (guestNode)
-        {
-            uint32_t memoryBalloonSize = 0;
-            CFGLDRQueryUInt32 (guestNode, "MemoryBalloonSize",
-                               &memoryBalloonSize);
-            mHWData->mMemoryBalloonSize = memoryBalloonSize;
-
-            uint32_t statisticsUpdateInterval = 0;
-            CFGLDRQueryUInt32 (guestNode, "StatisticsUpdateInterval",
-                               &statisticsUpdateInterval);
-            mHWData->mStatisticsUpdateInterval = statisticsUpdateInterval;
-
-            CFGLDRReleaseNode (guestNode);
-        }
-    }
-
-    return S_OK;
+    /// @todo (dmik) make required on next format change and change attribute
+    /// naming!
+    {
+        Key guestNode = aNode.findKey ("Guest");
+        if (!guestNode.isNull())
+        {
+            /* optional, defaults to 0) */
+            mHWData->mMemoryBalloonSize =
+                guestNode.value <ULONG> ("MemoryBalloonSize");
+            /* optional, defaults to 0) */
+            mHWData->mStatisticsUpdateInterval =
+                guestNode.value <ULONG> ("StatisticsUpdateInterval");
+        }
+    }
+
+    AssertComRC (rc);
+    return rc;
 }
 
 /**
- *  @param aNode        <HardDiskAttachments> node
+ *  @param aNode        <HardDiskAttachments> node.
  *  @param aRegistered  true when the machine is being loaded on VirtualBox
  *                      startup, or when a snapshot is being loaded (wchich
@@ -4955 +4370 @@
  *  @param aSnapshotId  pointer to the snapshot ID if this is a snapshot machine
  */
-HRESULT Machine::loadHardDisks (CFGNODE aNode, bool aRegistered,
+HRESULT Machine::loadHardDisks (const settings::Key &aNode, bool aRegistered,
                                 const Guid *aSnapshotId /* = NULL */)
 {
-    AssertReturn (aNode, E_INVALIDARG);
+    using namespace settings;
+
+    AssertReturn (!aNode.isNull(), E_INVALIDARG);
     AssertReturn ((mType == IsMachine && aSnapshotId == NULL) ||
                   (mType == IsSnapshotMachine && aSnapshotId != NULL), E_FAIL);
@@ -4964 +4381 @@
     HRESULT rc = S_OK;
 
-    unsigned cbDisks = 0;
-    CFGLDRCountChildren (aNode, "HardDiskAttachment", &cbDisks);
-
-    if (!aRegistered && cbDisks > 0)
+    Key::List children = aNode.keys ("HardDiskAttachment");
+
+    if (!aRegistered && children.size() > 0)
     {
         /* when the machine is being loaded (opened) from a file, it cannot
@@ -4976 +4392 @@
             tr ("Unregistered machine '%ls' cannot have hard disks attached "
                 "(found %d hard disk attachments)"),
-            mUserData->mName.raw(), cbDisks);
-    }
-
-    for (unsigned i = 0; i < cbDisks && SUCCEEDED (rc); ++ i)
-    {
-        CFGNODE hdNode;
-        CFGLDRGetChildNode (aNode, "HardDiskAttachment", i, &hdNode);
-        ComAssertRet (hdNode, E_FAIL);
-
-        do
-        {
-            /* hardDisk uuid (required) */
-            Guid uuid;
-            CFGLDRQueryUUID (hdNode, "hardDisk", uuid.ptr());
-            /* bus (controller) type (required) */
-            Bstr bus;
-            CFGLDRQueryBSTR (hdNode, "bus", bus.asOutParam());
-            /* device (required) */
-            Bstr device;
-            CFGLDRQueryBSTR (hdNode, "device", device.asOutParam());
-
-            /* find a hard disk by UUID */
-            ComObjPtr <HardDisk> hd;
-            rc = mParent->getHardDisk (uuid, hd);
-            if (FAILED (rc))
-                break;
-
-            AutoLock hdLock (hd);
-
-            if (!hd->machineId().isEmpty())
-            {
-                rc = setError (E_FAIL,
-                    tr ("Hard disk '%ls' with UUID {%s} is already "
-                        "attached to a machine with UUID {%s} (see '%ls')"),
-                    hd->toString().raw(), uuid.toString().raw(),
-                    hd->machineId().toString().raw(),
-                    mData->mConfigFileFull.raw());
-                break;
-            }
-
-            if (hd->type() == HardDiskType_ImmutableHardDisk)
-            {
-                rc = setError (E_FAIL,
-                    tr ("Immutable hard disk '%ls' with UUID {%s} cannot be "
-                        "directly attached to a machine (see '%ls')"),
-                    hd->toString().raw(), uuid.toString().raw(),
-                    mData->mConfigFileFull.raw());
-                break;
-            }
-
-            /* attach the device */
-            DiskControllerType_T ctl = DiskControllerType_InvalidController;
-            LONG dev = -1;
-
-            if (bus == L"ide0")
-            {
-                ctl = DiskControllerType_IDE0Controller;
-                if (device == L"master")
-                    dev = 0;
-                else if (device == L"slave")
-                    dev = 1;
-                else
-                    ComAssertMsgFailedBreak (("Invalid device: %ls\n", device.raw()),
-                                             rc = E_FAIL);
-            }
-            else if (bus == L"ide1")
-            {
-                ctl = DiskControllerType_IDE1Controller;
-                if (device == L"master")
-                    rc = setError (E_FAIL, tr("Could not attach a disk as a master "
-                                              "device on the secondary controller"));
-                else if (device == L"slave")
-                    dev = 1;
-                else
-                    ComAssertMsgFailedBreak (("Invalid device: %ls\n", device.raw()),
-                                             rc = E_FAIL);
-            }
+            mUserData->mName.raw(), children.size());
+    }
+
+
+    for (Key::List::const_iterator it = children.begin();
+         it != children.end(); ++ it)
+    {
+        /* hardDisk uuid (required) */
+        Guid uuid = (*it).value <Guid> ("hardDisk");
+        /* bus (controller) type (required) */
+        const char *bus = (*it).stringValue ("bus");
+        /* device (required) */
+        const char *device = (*it).stringValue ("device");
+
+        /* find a hard disk by UUID */
+        ComObjPtr <HardDisk> hd;
+        rc = mParent->getHardDisk (uuid, hd);
+        CheckComRCReturnRC (rc);
+
+        AutoLock hdLock (hd);
+
+        if (!hd->machineId().isEmpty())
+        {
+            return setError (E_FAIL,
+                tr ("Hard disk '%ls' with UUID {%s} is already "
+                    "attached to a machine with UUID {%s} (see '%ls')"),
+                hd->toString().raw(), uuid.toString().raw(),
+                hd->machineId().toString().raw(),
+                mData->mConfigFileFull.raw());
+        }
+
+        if (hd->type() == HardDiskType_ImmutableHardDisk)
+        {
+            return setError (E_FAIL,
+                tr ("Immutable hard disk '%ls' with UUID {%s} cannot be "
+                    "directly attached to a machine (see '%ls')"),
+                hd->toString().raw(), uuid.toString().raw(),
+                mData->mConfigFileFull.raw());
+        }
+
+        /* attach the device */
+        DiskControllerType_T ctl = DiskControllerType_InvalidController;
+        LONG dev = -1;
+
+        if (strcmp (bus, "ide0") == 0)
+        {
+            ctl = DiskControllerType_IDE0Controller;
+            if (strcmp (device, "master") == 0)
+                dev = 0;
+            else if (strcmp (device, "slave") == 0)
+                dev = 1;
             else
-                ComAssertMsgFailedBreak (("Invalid bus: %ls\n", bus.raw()),
-                                         rc = E_FAIL);
-
-            ComObjPtr <HardDiskAttachment> attachment;
-            attachment.createObject();
-            rc = attachment->init (hd, ctl, dev, false /* aDirty */);
-            if (FAILED (rc))
-                break;
-
-            /* associate the hard disk with this machine */
-            hd->setMachineId (mData->mUuid);
-
-            /* associate the hard disk with the given snapshot ID */
-            if (mType == IsSnapshotMachine)
-                hd->setSnapshotId (*aSnapshotId);
-
-            mHDData->mHDAttachments.push_back (attachment);
-        }
-        while (0);
-
-        CFGLDRReleaseNode (hdNode);
-    }
-
-    return rc;
-}
-
-/**
- *  Creates a config loader and loads the settings file.
- *
- *  @param aIsNew   |true| if a newly created settings file is to be opened
- *                  (must be the case only when called from #saveSettings())
- *
- *  @note
- *      XML Schema errors are not detected by this method because
- *      it assumes that it will load settings from an exclusively locked
- *      file (using a file handle) that was previously validated when opened
- *      for the first time. Thus, this method should be used only when
- *      it's necessary to modify (save) the settings file.
- *
- *  @note The object must be locked at least for reading before calling
- *        this method.
- */
-HRESULT Machine::openConfigLoader (CFGHANDLE *aLoader, bool aIsNew /* = false */)
-{
-    AssertReturn (aLoader, E_FAIL);
-
-    /* The settings file must be created and locked at this point */
-    ComAssertRet (isConfigLocked(), E_FAIL);
-
-    /* load the config file */
-    int vrc = CFGLDRLoad (aLoader,
-                          Utf8Str (mData->mConfigFileFull), mData->mHandleCfgFile,
-                          aIsNew ? NULL : XmlSchemaNS, true, cfgLdrEntityResolver,
-                          NULL);
-    ComAssertRCRet (vrc, E_FAIL);
+                ComAssertMsgFailedRet (("Invalid device '%s'\n", device),
+                                       E_FAIL);
+        }
+        else if (strcmp (bus, "ide1") == 0)
+        {
+            ctl = DiskControllerType_IDE1Controller;
+            if (strcmp (device, "master") == 0)
+                rc = setError (E_FAIL, tr("Could not attach a disk as a master "
+                                          "device on the secondary controller"));
+            else if (strcmp (device, "slave") == 0)
+                dev = 1;
+            else
+                ComAssertMsgFailedRet (("Invalid device '%s'\n", device),
+                                       E_FAIL);
+        }
+        else
+            ComAssertMsgFailedRet (("Invalid bus '%s'\n", bus),
+                                   E_FAIL);
+
+        ComObjPtr <HardDiskAttachment> attachment;
+        attachment.createObject();
+        rc = attachment->init (hd, ctl, dev, false /* aDirty */);
+        CheckComRCBreakRC (rc);
+
+        /* associate the hard disk with this machine */
+        hd->setMachineId (mData->mUuid);
+
+        /* associate the hard disk with the given snapshot ID */
+        if (mType == IsSnapshotMachine)
+            hd->setSnapshotId (*aSnapshotId);
+
+        mHDData->mHDAttachments.push_back (attachment);
+    }
 
     return S_OK;
-}
-
-/**
- *  Closes the config loader previously created by #openConfigLoader().
- *  If \a aSaveBeforeClose is true, then the config is saved to the settings file
- *  before closing. If saving fails, a proper error message is set.
- *
- *  @param aSaveBeforeClose whether to save the config before closing or not
- */
-HRESULT Machine::closeConfigLoader (CFGHANDLE aLoader, bool aSaveBeforeClose)
-{
-    HRESULT rc = S_OK;
-
-    if (aSaveBeforeClose)
-    {
-        char *loaderError = NULL;
-        int vrc = CFGLDRSave (aLoader, &loaderError);
-        if (VBOX_FAILURE (vrc))
-        {
-            rc = setError (E_FAIL,
-                tr ("Could not save the settings file '%ls' (%Vrc)%s%s"),
-                mData->mConfigFileFull.raw(), vrc,
-                loaderError ? ".\n" : "", loaderError ? loaderError : "");
-            if (loaderError)
-                RTMemTmpFree (loaderError);
-        }
-    }
-
-    CFGLDRFree (aLoader);
-
-    return rc;
 }
 
@@ -5153 +4490 @@
  *  \a aSnapshotNode are set to 0.
  *
- *  @param aSnapshot        snapshot to search for
- *  @param aMachineNode     <Machine> node to start from
+ *  @param aSnapshot        Snapshot to search for.
+ *  @param aMachineNode     <Machine> node to start from.
  *  @param aSnapshotsNode   <Snapshots> node containing the found <Snapshot> node
- *                          (may be NULL if the caller is not interested)
- *  @param aSnapshotNode    found <Snapshot> node
+ *                          (may be NULL if the caller is not interested).
+ *  @param aSnapshotNode    Found <Snapshot> node.
  */
-HRESULT Machine::findSnapshotNode (Snapshot *aSnapshot, CFGNODE aMachineNode,
-                                   CFGNODE *aSnapshotsNode, CFGNODE *aSnapshotNode)
-{
-    AssertReturn (aSnapshot && aMachineNode && aSnapshotNode, E_FAIL);
+HRESULT Machine::findSnapshotNode (Snapshot *aSnapshot, settings::Key &aMachineNode,
+                                   settings::Key *aSnapshotsNode,
+                                   settings::Key *aSnapshotNode)
+{
+    using namespace settings;
+
+    AssertReturn (aSnapshot && !aMachineNode.isNull()
+                  && aSnapshotNode != NULL, E_FAIL);
 
     if (aSnapshotsNode)
-        *aSnapshotsNode = 0;
-    *aSnapshotNode = 0;
-
-    // build the full uuid path (from the fist parent to the given snapshot)
+        aSnapshotsNode->setNull();
+    aSnapshotNode->setNull();
+
+    // build the full uuid path (from the top parent to the given snapshot)
     std::list <Guid> path;
     {
@@ -5179 +4520 @@
     }
 
-    CFGNODE snapshotsNode = aMachineNode;
-    CFGNODE snapshotNode = 0;
+    Key snapshotsNode = aMachineNode;
+    Key snapshotNode;
 
     for (std::list <Guid>::const_iterator it = path.begin();
@@ -5186 +4527 @@
          ++ it)
     {
-        if (snapshotNode)
-        {
-            // proceed to the nested <Snapshots> node
-            Assert (snapshotsNode);
-            if (snapshotsNode != aMachineNode)
-            {
-                CFGLDRReleaseNode (snapshotsNode);
-                snapshotsNode = 0;
-            }
-            CFGLDRGetChildNode (snapshotNode, "Snapshots", 0, &snapshotsNode);
-            CFGLDRReleaseNode (snapshotNode);
-            snapshotNode = 0;
-        }
-
-        AssertReturn (snapshotsNode, E_FAIL);
-
-        unsigned count = 0, i = 0;
-        CFGLDRCountChildren (snapshotsNode, "Snapshot", &count);
-        for (; i < count; ++ i)
-        {
-            snapshotNode = 0;
-            CFGLDRGetChildNode (snapshotsNode, "Snapshot", i, &snapshotNode);
-            Guid id;
-            CFGLDRQueryUUID (snapshotNode, "uuid", id.ptr());
+        if (!snapshotNode.isNull())
+        {
+            /* proceed to the nested <Snapshots> node */
+            snapshotsNode = snapshotNode.key ("Snapshots");
+            snapshotNode.setNull();
+        }
+
+        AssertReturn (!snapshotsNode.isNull(), E_FAIL);
+
+        Key::List children = snapshotsNode.keys ("Snapshot");
+        for (Key::List::const_iterator ch = children.begin();
+             ch != children.end();
+             ++ ch)
+        {
+            Guid id = (*ch).value <Guid> ("uuid");
             if (id == (*it))
             {
-                // we keep (don't release) snapshotNode and snapshotsNode
+                /* pass over to the outer loop */
+                snapshotNode = *ch;
                 break;
             }
-            CFGLDRReleaseNode (snapshotNode);
-            snapshotNode = 0;
-        }
-
-        if (i == count)
-        {
-            // the next uuid is not found, no need to continue...
-            AssertFailed();
-            if (snapshotsNode != aMachineNode)
-            {
-                CFGLDRReleaseNode (snapshotsNode);
-                snapshotsNode = 0;
-            }
-            break;
-        }
+        }
+
+        if (!snapshotNode.isNull())
+            continue;
+
+        /* the next uuid is not found, no need to continue... */
+        AssertFailedBreakVoid();
     }
 
     // we must always succesfully find the node
-    AssertReturn (snapshotNode, E_FAIL);
-    AssertReturn (snapshotsNode, E_FAIL);
-
-    if (aSnapshotsNode)
-        *aSnapshotsNode = snapshotsNode != aMachineNode ? snapshotsNode : 0;
+    AssertReturn (!snapshotNode.isNull(), E_FAIL);
+    AssertReturn (!snapshotsNode.isNull(), E_FAIL);
+
+    if (aSnapshotsNode && (snapshotsNode != aMachineNode))
+        *aSnapshotsNode = snapshotsNode;
     *aSnapshotNode = snapshotNode;
 
@@ -5382 +4707 @@
  *  if this is a new machine.
  *
- *  @note Must be never called directly.
+ *  @note Must be never called directly but only from #saveSettings().
  *
  *  @param aRenamed receives |true| if the name was changed and the settings
@@ -5391 +4716 @@
 HRESULT Machine::prepareSaveSettings (bool &aRenamed, bool &aNew)
 {
+    /* Note: tecnhically, mParent needs to be locked only when the machine is
+     * registered (see prepareSaveSettings() for details) but we don't
+     * currently differentiate it in callers of saveSettings() so we don't
+     * make difference here too.  */
+    AssertReturn (mParent->isLockedOnCurrentThread(), E_FAIL);
+    AssertReturn (isLockedOnCurrentThread(), E_FAIL);
+
     HRESULT rc = S_OK;
 
@@ -5573 +4905 @@
         }
 
-        /* Note: open flags must correlated with RTFileOpen() in lockConfig() */
+        /* Note: open flags must correlate with RTFileOpen() in lockConfig() */
         path = Utf8Str (mData->mConfigFileFull);
         vrc = RTFileOpen (&mData->mHandleCfgFile, path,
@@ -5601 +4933 @@
  *
  *  @param aMarkCurStateAsModified
- *      if true (default), mData->mCurrentStateModified will be set to
+ *      If true (default), mData->mCurrentStateModified will be set to
  *      what #isReallyModified() returns prior to saving settings to a file,
  *      otherwise the current value of mData->mCurrentStateModified will be
  *      saved.
  *  @param aInformCallbacksAnyway
- *      if true, callbacks will be informed even if #isReallyModified()
+ *      If true, callbacks will be informed even if #isReallyModified()
  *      returns false. This is necessary for cases when we change machine data
  *      diectly, not through the backup()/commit() mechanism.
  *
- *  @note Locks mParent (only in some cases, and only when #isConfigLocked() is
- *        |TRUE|, see the #prepareSaveSettings() code for details) +
- *        this object + children for writing.
+ *  @note Must be called from under mParent write lock (sometimes needed by
+ *  #prepareSaveSettings()) and this object's write lock. Locks children for
+ *  writing. There is one exception when mParent is unused and therefore may
+ *  be left unlocked: if this machine is an unregistered one.
  */
 HRESULT Machine::saveSettings (bool aMarkCurStateAsModified /* = true */,
@@ -5618 +4951 @@
 {
     LogFlowThisFuncEnter();
+
+    /* Note: tecnhically, mParent needs to be locked only when the machine is
+     * registered (see prepareSaveSettings() for details) but we don't
+     * currently differentiate it in callers of saveSettings() so we don't
+     * make difference here too.  */
+    AssertReturn (mParent->isLockedOnCurrentThread(), E_FAIL);
+    AssertReturn (isLockedOnCurrentThread(), E_FAIL);
 
     /// @todo (dmik) I guess we should lock all our child objects here
@@ -5658 +4998 @@
     CheckComRCReturnRC (rc);
 
-    /* then, open the settings file */
-    CFGHANDLE configLoader = 0;
-    rc = openConfigLoader (&configLoader, isNew);
-    CheckComRCReturnRC (rc);
-
-    /* save all snapshots when the machine name was changed since
-     * it may affect saved state file paths for online snapshots (see
-     * #openConfigLoader() for details) */
-    bool updateAllSnapshots = isRenamed;
-
-    /* commit before saving, since it may change settings
-     * (for example, perform fixup of lazy hard disk changes) */
-    rc = commit();
-    if (FAILED (rc))
-    {
-        closeConfigLoader (configLoader, false /* aSaveBeforeClose */);
-        return rc;
-    }
-
-    /* include hard disk changes to the modified flag */
-    wasModified |= mHDData->mHDAttachmentsChanged;
-    if (aMarkCurStateAsModified)
-        mData->mCurrentStateModified |= BOOL (mHDData->mHDAttachmentsChanged);
-
-
-    CFGNODE machineNode = 0;
-    /* create if not exists */
-    CFGLDRCreateNode (configLoader, "VirtualBox/Machine", &machineNode);
-
-    do
-    {
-        ComAssertBreak (machineNode, rc = E_FAIL);
+    try
+    {
+        using namespace settings;
+
+        File file (File::ReadWrite, mData->mHandleCfgFile,
+                   Utf8Str (mData->mConfigFileFull));
+        XmlTreeBackend tree;
+
+        /* The newly created settings file is incomplete therefore we turn off
+         * validation. The rest is like in loadSettingsTree_ForUpdate().*/
+        rc = VirtualBox::loadSettingsTree (tree, file,
+                                           !isNew /* aValidate */,
+                                           false /* aCatchLoadErrors */,
+                                           false /* aAddDefaults */);
+        CheckComRCThrowRC (rc);
+
+
+        /* ask to save all snapshots when the machine name was changed since
+         * it may affect saved state file paths for online snapshots (see
+         * #openConfigLoader() for details) */
+        bool updateAllSnapshots = isRenamed;
+
+        /* commit before saving, since it may change settings
+         * (for example, perform fixup of lazy hard disk changes) */
+        rc = commit();
+        CheckComRCReturnRC (rc);
+
+        /* include hard disk changes to the modified flag */
+        wasModified |= mHDData->mHDAttachmentsChanged;
+        if (aMarkCurStateAsModified)
+            mData->mCurrentStateModified |= BOOL (mHDData->mHDAttachmentsChanged);
+
+        Key machineNode = tree.rootKey().createKey ("Machine");
 
         /* uuid (required) */
-        Assert (mData->mUuid);
-        CFGLDRSetUUID (machineNode, "uuid", mData->mUuid.raw());
+        Assert (!mData->mUuid.isEmpty());
+        machineNode.setValue <Guid> ("uuid", mData->mUuid);
 
         /* name (required) */
         Assert (!mUserData->mName.isEmpty());
-        CFGLDRSetBSTR (machineNode, "name", mUserData->mName);
+        machineNode.setValue <Bstr> ("name", mUserData->mName);
 
         /* nameSync (optional, default is true) */
-        if (!mUserData->mNameSync)
-            CFGLDRSetBool (machineNode, "nameSync", false);
-        else
-            CFGLDRDeleteAttribute (machineNode, "nameSync");
+        machineNode.setValueOr <bool> ("nameSync", !!mUserData->mNameSync, true);
 
         /* Description node (optional) */
         if (!mUserData->mDescription.isNull())
         {
-            CFGNODE descNode = 0;
-            CFGLDRCreateChildNode (machineNode, "Description", &descNode);
-            Assert (descNode);
-            CFGLDRSetBSTR (descNode, NULL, mUserData->mDescription);
-            CFGLDRReleaseNode (descNode);
+            Key descNode = machineNode.createKey ("Description");
+            descNode.setKeyValue <Bstr> (mUserData->mDescription);
         }
         else
         {
-            CFGNODE descNode = 0;
-            CFGLDRGetChildNode (machineNode, "Description", 0, &descNode);
-            if (descNode)
-                CFGLDRDeleteNode (descNode);
+            Key descNode = machineNode.findKey ("Description");
+            if (!descNode.isNull())
+                descNode.zap();
         }
 
         /* OSType (required) */
-        {
-            CFGLDRSetBSTR (machineNode, "OSType", mUserData->mOSTypeId);
-        }
+        machineNode.setValue <Bstr> ("OSType", mUserData->mOSTypeId);
 
         /* stateFile (optional) */
@@ -5734 +5066 @@
             Utf8Str stateFilePath = mSSData->mStateFilePath;
             calculateRelativePath (stateFilePath, stateFilePath);
-            CFGLDRSetString (machineNode, "stateFile", stateFilePath);
+            machineNode.setStringValue ("stateFile", stateFilePath);
         }
         else
         {
             Assert (mSSData->mStateFilePath.isNull());
-            CFGLDRDeleteAttribute (machineNode, "stateFile");
+            machineNode.zapValue ("stateFile");
         }
 
@@ -5746 +5078 @@
         {
             Assert (!mData->mFirstSnapshot.isNull());
-            CFGLDRSetUUID (machineNode, "currentSnapshot",
-                           mData->mCurrentSnapshot->data().mId);
+            machineNode.setValue <Guid> ("currentSnapshot",
+                                         mData->mCurrentSnapshot->data().mId);
         }
         else
         {
             Assert (mData->mFirstSnapshot.isNull());
-            CFGLDRDeleteAttribute (machineNode, "currentSnapshot");
+            machineNode.zapValue ("currentSnapshot");
         }
 
         /* snapshotFolder (optional) */
+        /// @todo use the Bstr::NullOrEmpty constant and setValueOr
         if (!mUserData->mSnapshotFolder.isEmpty())
-            CFGLDRSetBSTR (machineNode, "snapshotFolder", mUserData->mSnapshotFolder);
+            machineNode.setValue <Bstr> ("snapshotFolder", mUserData->mSnapshotFolder);
         else
-            CFGLDRDeleteAttribute (machineNode, "snapshotFolder");
-
-        /* currentStateModified (optional, default is yes) */
-        if (!mData->mCurrentStateModified)
-            CFGLDRSetBool (machineNode, "currentStateModified", false);
-        else
-            CFGLDRDeleteAttribute (machineNode, "currentStateModified");
+            machineNode.zapValue ("snapshotFolder");
+
+        /* currentStateModified (optional, default is true) */
+        machineNode.setValueOr <bool> ("currentStateModified",
+                                       !!mData->mCurrentStateModified, true);
 
         /* lastStateChange */
-        CFGLDRSetDateTime (machineNode, "lastStateChange",
-                           mData->mLastStateChange);
+        machineNode.setValue <RTTIMESPEC> ("lastStateChange",
+                                           mData->mLastStateChange);
+
+        /* set the aborted attribute when appropriate, defaults to false */
+        machineNode.setValueOr <bool> ("aborted",
+                                       mData->mMachineState == MachineState_Aborted,
+                                       false);
 
         /* Hardware node (required) */
         {
-            CFGNODE hwNode = 0;
-            CFGLDRGetChildNode (machineNode, "Hardware", 0, &hwNode);
             /* first, delete the entire node if exists */
-            if (hwNode)
-                CFGLDRDeleteNode (hwNode);
+            Key hwNode = machineNode.findKey ("Hardware");
+            if (!hwNode.isNull())
+                hwNode.zap();
             /* then recreate it */
-            hwNode = 0;
-            CFGLDRCreateChildNode (machineNode, "Hardware", &hwNode);
-            ComAssertBreak (hwNode, rc = E_FAIL);
-
+            hwNode = machineNode.createKey ("Hardware");
+            
             rc = saveHardware (hwNode);
-
-            CFGLDRReleaseNode (hwNode);
-            if (FAILED (rc))
-                break;
+            CheckComRCThrowRC (rc);
         }
 
         /* HardDiskAttachments node (required) */
         {
-            CFGNODE hdasNode = 0;
-            CFGLDRGetChildNode (machineNode, "HardDiskAttachments", 0, &hdasNode);
             /* first, delete the entire node if exists */
-            if (hdasNode)
-                CFGLDRDeleteNode (hdasNode);
+            Key hdaNode = machineNode.findKey ("HardDiskAttachments");
+            if (!hdaNode.isNull())
+                hdaNode.zap();
             /* then recreate it */
-            hdasNode = 0;
-            CFGLDRCreateChildNode (machineNode, "HardDiskAttachments", &hdasNode);
-            ComAssertBreak (hdasNode, rc = E_FAIL);
-
-            rc = saveHardDisks (hdasNode);
-
-            CFGLDRReleaseNode (hdasNode);
-            if (FAILED (rc))
-                break;
+            hdaNode = machineNode.createKey ("HardDiskAttachments");
+
+            rc = saveHardDisks (hdaNode);
+            CheckComRCThrowRC (rc);
         }
 
         /* update all snapshots if requested */
         if (updateAllSnapshots)
+        {
             rc = saveSnapshotSettingsWorker (machineNode, NULL,
                                              SaveSS_UpdateAllOp);
-    }
-    while (0);
-
-    if (machineNode)
-        CFGLDRReleaseNode (machineNode);
-
-    if (SUCCEEDED (rc))
-        rc = closeConfigLoader (configLoader, true /* aSaveBeforeClose */);
-    else
-        closeConfigLoader (configLoader, false /* aSaveBeforeClose */);
+            CheckComRCThrowRC (rc);
+        }
+
+        /* save the settings on success */
+        rc = VirtualBox::saveSettingsTree (tree, file);
+        CheckComRCThrowRC (rc);
+    }
+    catch (HRESULT err)
+    {
+        /* we assume that error info is set by the thrower */
+        rc = err;
+    }
+    catch (...)
+    {
+        rc = VirtualBox::handleUnexpectedExceptions (RT_SRC_POS);
+    }
 
     if (FAILED (rc))
     {
-        /*
-         *  backup arbitrary data item to cause #isModified() to still return
-         *  true in case of any error
-         */
+        /* backup arbitrary data item to cause #isModified() to still return
+         * true in case of any error */
         mHWData.backup();
     }
@@ -5835 +5164 @@
     if (wasModified || aInformCallbacksAnyway)
     {
-        /*
-         *  Fire the data change event, even on failure (since we've already
-         *  committed all data). This is done only for SessionMachines because
-         *  mutable Machine instances are always not registered (i.e. private
-         *  to the client process that creates them) and thus don't need to
-         *  inform callbacks.
-         */
+        /* Fire the data change event, even on failure (since we've already
+         * committed all data). This is done only for SessionMachines because
+         * mutable Machine instances are always not registered (i.e. private
+         * to the client process that creates them) and thus don't need to
+         * inform callbacks. */
         if (mType == IsSessionMachine)
             mParent->onMachineDataChange (mData->mUuid);
@@ -5876 +5203 @@
     HRESULT rc = S_OK;
 
-    /* load the config file */
-    CFGHANDLE configLoader = 0;
-    rc = openConfigLoader (&configLoader);
-    if (FAILED (rc))
-        return rc;
-
-    CFGNODE machineNode = 0;
-    CFGLDRGetNode (configLoader, "VirtualBox/Machine", 0, &machineNode);
-
-    do
-    {
-        ComAssertBreak (machineNode, rc = E_FAIL);
+    try
+    {
+        using namespace settings;
+
+        /* load the config file */
+        File file (File::ReadWrite, mData->mHandleCfgFile,
+                   Utf8Str (mData->mConfigFileFull));
+        XmlTreeBackend tree;
+
+        rc = VirtualBox::loadSettingsTree_ForUpdate (tree, file);
+        CheckComRCReturnRC (rc);
+
+        Key machineNode = tree.rootKey().key ("Machine");
 
         rc = saveSnapshotSettingsWorker (machineNode, aSnapshot, aOpFlags);
-
-        CFGLDRReleaseNode (machineNode);
-    }
-    while (0);
-
-    if (SUCCEEDED (rc))
-        rc = closeConfigLoader (configLoader, true /* aSaveBeforeClose */);
-    else
-        closeConfigLoader (configLoader, false /* aSaveBeforeClose */);
+        CheckComRCReturnRC (rc);
+
+        /* save settings on success */
+        rc = VirtualBox::saveSettingsTree (tree, file);
+        CheckComRCReturnRC (rc);
+    }
+    catch (...)
+    {
+        rc = VirtualBox::handleUnexpectedExceptions (RT_SRC_POS);
+    }
 
     return rc;
@@ -5915 +5244 @@
  *  attribute of <Machine> needs to be updated.
  *
- *  @param aMachineNode <Machine> node in the opened settings file
- *  @param aSnapshot    Snapshot to operate on
+ *  @param aMachineNode <Machine> node in the opened settings file.
+ *  @param aSnapshot    Snapshot to operate on.
  *  @param aOpFlags     Operation to perform, one of SaveSS_NoOp, SaveSS_AddOp
  *                      or SaveSS_UpdateAttrsOp possibly combined with
@@ -5924 +5253 @@
  *        Locks child objects.
  */
-HRESULT Machine::saveSnapshotSettingsWorker (CFGNODE aMachineNode,
+HRESULT Machine::saveSnapshotSettingsWorker (settings::Key &aMachineNode,
                                              Snapshot *aSnapshot, int aOpFlags)
 {
-    AssertReturn (aMachineNode, E_FAIL);
+    using namespace settings;
+
+    AssertReturn (!aMachineNode.isNull(), E_FAIL);
 
     AssertReturn (isLockedOnCurrentThread(), E_FAIL);
@@ -5952 +5283 @@
         {
             /* first, delete the entire root snapshot node if it exists */
-            CFGNODE snapshotNode = 0;
-            CFGLDRGetChildNode (aMachineNode, "Snapshot", 0, &snapshotNode);
-            if (snapshotNode)
-                CFGLDRDeleteNode (snapshotNode);
-
-            /*
-             *  second, if we have any snapshots left, substitute aSnapshot with
-             *  the first snapshot to recreate the whole tree, otherwise break
-             */
+            Key snapshotNode = aMachineNode.findKey ("Snapshot");
+            if (!snapshotNode.isNull())
+                snapshotNode.zap();
+
+            /* second, if we have any snapshots left, substitute aSnapshot
+             * with the first snapshot to recreate the whole tree, otherwise
+             * break */
             if (mData->mFirstSnapshot)
             {
@@ -5975 +5304 @@
         if (op == SaveSS_AddOp)
         {
-            CFGNODE parentNode = 0;
+            Key parentNode;
 
             if (parent)
             {
                 rc = findSnapshotNode (parent, aMachineNode, NULL, &parentNode);
-                if (FAILED (rc))
-                    break;
-                ComAssertBreak (parentNode, rc = E_FAIL);
+                CheckComRCBreakRC (rc);
+
+                ComAssertBreak (!parentNode.isNull(), rc = E_FAIL);
             }
 
             do
             {
-                CFGNODE snapshotsNode = 0;
-
-                if (parentNode)
-                {
-                    CFGLDRCreateChildNode (parentNode, "Snapshots", &snapshotsNode);
-                    ComAssertBreak (snapshotsNode, rc = E_FAIL);
-                }
+                Key snapshotsNode;
+
+                if (!parentNode.isNull())
+                    snapshotsNode = parentNode.createKey ("Snapshots");
                 else
                     snapshotsNode = aMachineNode;
                 do
                 {
-                    CFGNODE snapshotNode = 0;
-                    CFGLDRAppendChildNode (snapshotsNode, "Snapshot", &snapshotNode);
-                    ComAssertBreak (snapshotNode, rc = E_FAIL);
+                    Key snapshotNode = snapshotsNode.appendKey ("Snapshot");
                     rc = saveSnapshot (snapshotNode, aSnapshot, false /* aAttrsOnly */);
-                    CFGLDRReleaseNode (snapshotNode);
-
-                    if (FAILED (rc))
-                        break;
-
-                    /*
-                     *  when a new snapshot is added, this means diffs were created
-                     *  for every normal/immutable hard disk of the VM, so we need to
-                     *  save the current hard disk attachments
-                     */
-
-                    CFGNODE hdasNode = 0;
-                    CFGLDRGetChildNode (aMachineNode, "HardDiskAttachments", 0, &hdasNode);
-                    if (hdasNode)
-                        CFGLDRDeleteNode (hdasNode);
-                    CFGLDRCreateChildNode (aMachineNode, "HardDiskAttachments", &hdasNode);
-                    ComAssertBreak (hdasNode, rc = E_FAIL);
-
-                    rc = saveHardDisks (hdasNode);
+                    CheckComRCBreakRC (rc);
+
+                    /* when a new snapshot is added, this means diffs were created
+                     * for every normal/immutable hard disk of the VM, so we need to
+                     * save the current hard disk attachments */
+
+                    Key hdaNode = aMachineNode.findKey ("HardDiskAttachments");
+                    if (!hdaNode.isNull())
+                        hdaNode.zap();
+                    hdaNode = aMachineNode.createKey ("HardDiskAttachments");
+
+                    rc = saveHardDisks (hdaNode);
+                    CheckComRCBreakRC (rc);
 
                     if (mHDData->mHDAttachments.size() != 0)
                     {
-                        /*
-                         *  If we have one or more attachments then we definitely
-                         *  created diffs for them and associated new diffs with
-                         *  current settngs. So, since we don't use saveSettings(),
-                         *  we need to inform callbacks manually.
-                         */
+                        /* If we have one or more attachments then we definitely
+                         * created diffs for them and associated new diffs with
+                         * current settngs. So, since we don't use saveSettings(),
+                         * we need to inform callbacks manually. */
                         if (mType == IsSessionMachine)
                             mParent->onMachineDataChange (mData->mUuid);
                     }
-
-                    CFGLDRReleaseNode (hdasNode);
                 }
                 while (0);
-
-                if (snapshotsNode != aMachineNode)
-                    CFGLDRReleaseNode (snapshotsNode);
             }
             while (0);
 
-            if (parentNode)
-                CFGLDRReleaseNode (parentNode);
-
             break;
         }
@@ -6052 +5360 @@
                 op == SaveSS_UpdateAllOp);
 
-        CFGNODE snapshotsNode = 0;
-        CFGNODE snapshotNode = 0;
+        Key snapshotsNode;
+        Key snapshotNode;
 
         if (!recreateWholeTree)
@@ -6059 +5367 @@
             rc = findSnapshotNode (aSnapshot, aMachineNode,
                                    &snapshotsNode, &snapshotNode);
-            if (FAILED (rc))
-                break;
-            ComAssertBreak (snapshotNode, rc = E_FAIL);
-        }
-
-        if (!snapshotsNode)
+            CheckComRCBreakRC (rc);
+        }
+
+        if (snapshotsNode.isNull())
             snapshotsNode = aMachineNode;
 
         if (op == SaveSS_UpdateAttrsOp)
             rc = saveSnapshot (snapshotNode, aSnapshot, true /* aAttrsOnly */);
-        else do
-        {
-            if (snapshotNode)
-            {
-                CFGLDRDeleteNode (snapshotNode);
-                snapshotNode = 0;
-            }
-            CFGLDRAppendChildNode (snapshotsNode, "Snapshot", &snapshotNode);
-            ComAssertBreak (snapshotNode, rc = E_FAIL);
+        else
+        {
+            if (!snapshotNode.isNull())
+                snapshotNode.zap();
+
+            snapshotNode = snapshotsNode.appendKey ("Snapshot");
             rc = saveSnapshot (snapshotNode, aSnapshot, false /* aAttrsOnly */);
-        }
-        while (0);
-
-        CFGLDRReleaseNode (snapshotNode);
-        if (snapshotsNode != aMachineNode)
-            CFGLDRReleaseNode (snapshotsNode);
+            CheckComRCBreakRC (rc);
+        }
     }
     while (0);
@@ -6094 +5393 @@
         {
             if (!mData->mCurrentSnapshot.isNull())
-                CFGLDRSetUUID (aMachineNode, "currentSnapshot",
-                               mData->mCurrentSnapshot->data().mId);
+                aMachineNode.setValue <Guid> ("currentSnapshot",
+                                              mData->mCurrentSnapshot->data().mId);
             else
-                CFGLDRDeleteAttribute (aMachineNode, "currentSnapshot");
+                aMachineNode.zapValue ("currentSnapshot");
         }
         if (aOpFlags & SaveSS_UpdateCurStateModified)
         {
-            if (!mData->mCurrentStateModified)
-                CFGLDRSetBool (aMachineNode, "currentStateModified", false);
-            else
-                CFGLDRDeleteAttribute (aMachineNode, "currentStateModified");
+            aMachineNode.setValue <bool> ("currentStateModified", true);
         }
     }
@@ -6115 +5411 @@
  *  It is assumed that the given node is empty (unless \a aAttrsOnly is true).
  *
- *  @param aNode        <Snapshot> node to save the snapshot to
- *  @param aSnapshot    snapshot to save
- *  @param aAttrsOnly   if true, only updatge user-changeable attrs
+ *  @param aNode        <Snapshot> node to save the snapshot to.
+ *  @param aSnapshot    Snapshot to save.
+ *  @param aAttrsOnly   If true, only updatge user-changeable attrs.
  */
-HRESULT Machine::saveSnapshot (CFGNODE aNode, Snapshot *aSnapshot, bool aAttrsOnly)
-{
-    AssertReturn (aNode && aSnapshot, E_INVALIDARG);
+HRESULT Machine::saveSnapshot (settings::Key &aNode, Snapshot *aSnapshot, bool aAttrsOnly)
+{
+    using namespace settings;
+
+    AssertReturn (!aNode.isNull() && aSnapshot, E_INVALIDARG);
     AssertReturn (mType == IsMachine || mType == IsSessionMachine, E_FAIL);
 
     /* uuid (required) */
     if (!aAttrsOnly)
-        CFGLDRSetUUID (aNode, "uuid", aSnapshot->data().mId);
+        aNode.setValue <Guid> ("uuid", aSnapshot->data().mId);
 
     /* name (required) */
-    CFGLDRSetBSTR (aNode, "name", aSnapshot->data().mName);
+    aNode.setValue <Bstr> ("name", aSnapshot->data().mName);
 
     /* timeStamp (required) */
-    CFGLDRSetDateTime (aNode, "timeStamp", aSnapshot->data().mTimeStamp);
+    aNode.setValue <RTTIMESPEC> ("timeStamp", aSnapshot->data().mTimeStamp);
 
     /* Description node (optional) */
     if (!aSnapshot->data().mDescription.isNull())
     {
-        CFGNODE descNode = 0;
-        CFGLDRCreateChildNode (aNode, "Description", &descNode);
-        Assert (descNode);
-        CFGLDRSetBSTR (descNode, NULL, aSnapshot->data().mDescription);
-        CFGLDRReleaseNode (descNode);
+        Key descNode = aNode.createKey ("Description");
+        descNode.setKeyValue <Bstr> (aSnapshot->data().mDescription);
     }
     else
     {
-        CFGNODE descNode = 0;
-        CFGLDRGetChildNode (aNode, "Description", 0, &descNode);
-        if (descNode)
-            CFGLDRDeleteNode (descNode);
+        Key descNode = aNode.findKey ("Description");
+        if (!descNode.isNull())
+            descNode.zap();
     }
 
@@ -6160 +5454 @@
         Utf8Str stateFilePath = aSnapshot->stateFilePath();
         calculateRelativePath (stateFilePath, stateFilePath);
-        CFGLDRSetString (aNode, "stateFile", stateFilePath);
+        aNode.setStringValue ("stateFile", stateFilePath);
     }
 
@@ -6169 +5463 @@
         /* save hardware */
         {
-            CFGNODE hwNode = 0;
-            CFGLDRCreateChildNode (aNode, "Hardware", &hwNode);
-
+            Key hwNode = aNode.createKey ("Hardware");
             HRESULT rc = snapshotMachine->saveHardware (hwNode);
-
-            CFGLDRReleaseNode (hwNode);
-            if (FAILED (rc))
-                return rc;
+            CheckComRCReturnRC (rc);
         }
 
         /* save hard disks */
         {
-            CFGNODE hdasNode = 0;
-            CFGLDRCreateChildNode (aNode, "HardDiskAttachments", &hdasNode);
-
+            Key hdasNode = aNode.createKey ("HardDiskAttachments");
             HRESULT rc = snapshotMachine->saveHardDisks (hdasNode);
-
-            CFGLDRReleaseNode (hdasNode);
-            if (FAILED (rc))
-                return rc;
+            CheckComRCReturnRC (rc);
         }
     }
@@ -6198 +5482 @@
         if (aSnapshot->children().size())
         {
-            CFGNODE snapshotsNode = 0;
-            CFGLDRCreateChildNode (aNode, "Snapshots", &snapshotsNode);
+            Key snapshotsNode = aNode.createKey ("Snapshots");
 
             HRESULT rc = S_OK;
 
             for (Snapshot::SnapshotList::const_iterator it = aSnapshot->children().begin();
-                 it != aSnapshot->children().end() && SUCCEEDED (rc);
+                 it != aSnapshot->children().end();
                  ++ it)
             {
-                CFGNODE snapshotNode = 0;
-                CFGLDRCreateChildNode (snapshotsNode, "Snapshot", &snapshotNode);
-
+                Key snapshotNode = snapshotsNode.createKey ("Snapshot");
                 rc = saveSnapshot (snapshotNode, (*it), aAttrsOnly);
-
-                CFGLDRReleaseNode (snapshotNode);
+                CheckComRCReturnRC (rc);
             }
-
-            CFGLDRReleaseNode (snapshotsNode);
-            if (FAILED (rc))
-                return rc;
         }
     }
@@ -6228 +5504 @@
  *  It is assumed that the given node is empty.
  *
- *  @param aNode    <Hardware> node to save the VM hardware confguration to
+ *  @param aNode    <Hardware> node to save the VM hardware confguration to.
  */
-HRESULT Machine::saveHardware (CFGNODE aNode)
-{
-    AssertReturn (aNode, E_INVALIDARG);
+HRESULT Machine::saveHardware (settings::Key &aNode)
+{
+    using namespace settings;
+
+    AssertReturn (!aNode.isNull(), E_INVALIDARG);
 
     HRESULT rc = S_OK;
 
-    /* CPU */
-    {
-        CFGNODE cpuNode = 0;
-        CFGLDRCreateChildNode (aNode, "CPU", &cpuNode);
-        CFGNODE hwVirtExNode = 0;
-        CFGLDRCreateChildNode (cpuNode, "HardwareVirtEx", &hwVirtExNode);
+    /* CPU (optional) */
+    {
+        Key cpuNode = aNode.createKey ("CPU");
+        Key hwVirtExNode = cpuNode.createKey ("HardwareVirtEx");
         const char *value = NULL;
         switch (mHWData->mHWVirtExEnabled)
@@ -6251 +5527 @@
                 value = "true";
                 break;
-            default:
+            case TriStateBool_Default:
                 value = "default";
         }
-        CFGLDRSetString (hwVirtExNode, "enabled", value);
-        CFGLDRReleaseNode (hwVirtExNode);
-        CFGLDRReleaseNode (cpuNode);
+        hwVirtExNode.setStringValue ("enabled", value);
     }
 
     /* memory (required) */
     {
-        CFGNODE memoryNode = 0;
-        CFGLDRCreateChildNode (aNode, "Memory", &memoryNode);
-        CFGLDRSetUInt32 (memoryNode, "RAMSize", mHWData->mMemorySize);
-        CFGLDRReleaseNode (memoryNode);
+        Key memoryNode = aNode.createKey ("Memory");
+        memoryNode.setValue <ULONG> ("RAMSize", mHWData->mMemorySize);
     }
 
     /* boot (required) */
-    do
-    {
-        CFGNODE bootNode = 0;
-        CFGLDRCreateChildNode (aNode, "Boot", &bootNode);
-
-        for (ULONG pos = 0; pos < ELEMENTS (mHWData->mBootOrder); pos ++)
+    {
+        Key bootNode = aNode.createKey ("Boot");
+
+        for (ULONG pos = 0; pos < ELEMENTS (mHWData->mBootOrder); ++ pos)
         {
             const char *device = NULL;
@@ -6282 +5552 @@
                      * when loading, the default value NoDevice will remain */
                     continue;
-                case DeviceType_FloppyDevice:   device = "Floppy";  break;
+                case DeviceType_FloppyDevice:   device = "Floppy"; break;
                 case DeviceType_DVDDevice:      device = "DVD"; break;
                 case DeviceType_HardDiskDevice: device = "HardDisk"; break;
                 case DeviceType_NetworkDevice:  device = "Network"; break;
                 default:
-                    ComAssertMsgFailedBreak (("Invalid boot device: %d\n",
-                                              mHWData->mBootOrder [pos]),
-                                              rc = E_FAIL);
+                {
+                    ComAssertMsgFailedRet (("Invalid boot device: %d\n",
+                                            mHWData->mBootOrder [pos]),
+                                            E_FAIL);
+                }
             }
-            if (FAILED (rc))
-                break;
-
-            CFGNODE orderNode = 0;
-            CFGLDRAppendChildNode (bootNode, "Order", &orderNode);
-
-            CFGLDRSetUInt32 (orderNode, "position", pos + 1);
-            CFGLDRSetString (orderNode, "device", device);
-
-            CFGLDRReleaseNode (orderNode);
-        }
-
-        CFGLDRReleaseNode (bootNode);
-    }
-    while (0);
-
-    CheckComRCReturnRC (rc);
+
+            Key orderNode = bootNode.appendKey ("Order");
+            orderNode.setValue <ULONG> ("position", pos + 1);
+            orderNode.setStringValue ("device", device);
+        }
+    }
 
     /* display (required) */
     {
-        CFGNODE displayNode = 0;
-        CFGLDRCreateChildNode (aNode, "Display", &displayNode);
-        CFGLDRSetUInt32 (displayNode, "VRAMSize", mHWData->mVRAMSize);
-        CFGLDRSetUInt32 (displayNode, "MonitorCount", mHWData->mMonitorCount);
-        CFGLDRReleaseNode (displayNode);
+        Key displayNode = aNode.createKey ("Display");
+        displayNode.setValue <ULONG> ("VRAMSize", mHWData->mVRAMSize);
+        displayNode.setValue <ULONG> ("MonitorCount", mHWData->mMonitorCount);
     }
 
 #ifdef VBOX_VRDP
     /* VRDP settings (optional) */
-    {
-        CFGNODE remoteDisplayNode = 0;
-        CFGLDRCreateChildNode (aNode, "RemoteDisplay", &remoteDisplayNode);
-        if (remoteDisplayNode)
-        {
-            rc = mVRDPServer->saveSettings (remoteDisplayNode);
-            CFGLDRReleaseNode (remoteDisplayNode);
-            CheckComRCReturnRC (rc);
-        }
-    }
+    rc = mVRDPServer->saveSettings (aNode);
+    CheckComRCReturnRC (rc);
 #endif
 
     /* BIOS (required) */
-    {
-        CFGNODE biosNode = 0;
-        CFGLDRCreateChildNode (aNode, "BIOS", &biosNode);
-        {
-            BOOL fSet;
-            /* ACPI */
-            CFGNODE acpiNode = 0;
-            CFGLDRCreateChildNode (biosNode, "ACPI", &acpiNode);
-            mBIOSSettings->COMGETTER(ACPIEnabled)(&fSet);
-            CFGLDRSetBool (acpiNode, "enabled", !!fSet);
-            CFGLDRReleaseNode (acpiNode);
-
-            /* IOAPIC */
-            CFGNODE ioapicNode = 0;
-            CFGLDRCreateChildNode (biosNode, "IOAPIC", &ioapicNode);
-            mBIOSSettings->COMGETTER(IOAPICEnabled)(&fSet);
-            CFGLDRSetBool (ioapicNode, "enabled", !!fSet);
-            CFGLDRReleaseNode (ioapicNode);
-
-            /* BIOS logo (optional) **/
-            CFGNODE logoNode = 0;
-            CFGLDRCreateChildNode (biosNode, "Logo", &logoNode);
-            mBIOSSettings->COMGETTER(LogoFadeIn)(&fSet);
-            CFGLDRSetBool (logoNode, "fadeIn", !!fSet);
-            mBIOSSettings->COMGETTER(LogoFadeOut)(&fSet);
-            CFGLDRSetBool (logoNode, "fadeOut", !!fSet);
-            ULONG ulDisplayTime;
-            mBIOSSettings->COMGETTER(LogoDisplayTime)(&ulDisplayTime);
-            CFGLDRSetUInt32 (logoNode, "displayTime", ulDisplayTime);
-            Bstr logoPath;
-            mBIOSSettings->COMGETTER(LogoImagePath)(logoPath.asOutParam());
-            if (logoPath)
-                CFGLDRSetBSTR (logoNode, "imagePath", logoPath);
-            else
-                CFGLDRDeleteAttribute (logoNode, "imagePath");
-            CFGLDRReleaseNode (logoNode);
-
-            /* boot menu (optional) */
-            CFGNODE bootMenuNode = 0;
-            CFGLDRCreateChildNode (biosNode, "BootMenu", &bootMenuNode);
-            BIOSBootMenuMode_T bootMenuMode;
-            Bstr bootMenuModeStr;
-            mBIOSSettings->COMGETTER(BootMenuMode)(&bootMenuMode);
-            switch (bootMenuMode)
-            {
-                case BIOSBootMenuMode_Disabled:
-                    bootMenuModeStr = "disabled";
-                    break;
-                case BIOSBootMenuMode_MenuOnly:
-                    bootMenuModeStr = "menuonly";
-                    break;
-                default:
-                    bootMenuModeStr = "messageandmenu";
-            }
-            CFGLDRSetBSTR (bootMenuNode, "mode", bootMenuModeStr);
-            CFGLDRReleaseNode (bootMenuNode);
-
-            /* time offset (optional) */
-            CFGNODE timeOffsetNode = 0;
-            CFGLDRCreateChildNode (biosNode, "TimeOffset", &timeOffsetNode);
-            LONG64 timeOffset;
-            mBIOSSettings->COMGETTER(TimeOffset)(&timeOffset);
-            CFGLDRSetInt64 (timeOffsetNode, "value", timeOffset);
-            CFGLDRReleaseNode (timeOffsetNode);
-
-            /* PXE debug flag (optional) */
-            CFGNODE pxedebugNode = 0;
-            CFGLDRCreateChildNode (biosNode, "PXEDebug", &pxedebugNode);
-            mBIOSSettings->COMGETTER(PXEDebugEnabled)(&fSet);
-            CFGLDRSetBool (pxedebugNode, "enabled", !!fSet);
-            CFGLDRReleaseNode (pxedebugNode);
-
-            /* IDE controller type */
-            CFGNODE ideControllerNode = 0;
-            IDEControllerType_T controllerType;
-            CFGLDRCreateChildNode (biosNode, "IDEController", &ideControllerNode);
-            mBIOSSettings->COMGETTER(IDEControllerType)(&controllerType);
-            switch (controllerType)
-            {
-                case IDEControllerType_IDEControllerPIIX3:
-                    CFGLDRSetString (ideControllerNode, "type", "PIIX3");
-                    break;
-                case IDEControllerType_IDEControllerPIIX4:
-                    CFGLDRSetString (ideControllerNode, "type", "PIIX4");
-                    break;
-                default:
-                    ComAssertMsgFailedBreak (("Invalid IDE Controller type: %d\n",
-                                              controllerType), rc = E_FAIL);
-            }
-            CFGLDRReleaseNode (ideControllerNode);
-
-        }
-        CFGLDRReleaseNode(biosNode);
-    }
+    rc = mBIOSSettings->saveSettings (aNode);
+    CheckComRCReturnRC (rc);
 
     /* DVD drive (required) */
-    /// @todo (dmik) move the code to DVDDrive
-    do
-    {
-        CFGNODE dvdNode = 0;
-        CFGLDRCreateChildNode (aNode, "DVDDrive", &dvdNode);
-
-        BOOL fPassthrough;
-        mDVDDrive->COMGETTER(Passthrough)(&fPassthrough);
-        CFGLDRSetBool(dvdNode, "passthrough", !!fPassthrough);
-
-        switch (mDVDDrive->data()->mDriveState)
-        {
-            case DriveState_ImageMounted:
-            {
-                Assert (!mDVDDrive->data()->mDVDImage.isNull());
-
-                Guid id;
-                rc = mDVDDrive->data()->mDVDImage->COMGETTER(Id) (id.asOutParam());
-                Assert (!id.isEmpty());
-
-                CFGNODE imageNode = 0;
-                CFGLDRCreateChildNode (dvdNode, "Image", &imageNode);
-                CFGLDRSetUUID (imageNode, "uuid", id.ptr());
-                CFGLDRReleaseNode (imageNode);
-                break;
-            }
-            case DriveState_HostDriveCaptured:
-            {
-                Assert (!mDVDDrive->data()->mHostDrive.isNull());
-
-                Bstr name;
-                rc = mDVDDrive->data()->mHostDrive->COMGETTER(Name) (name.asOutParam());
-                Assert (!name.isEmpty());
-
-                CFGNODE hostDriveNode = 0;
-                CFGLDRCreateChildNode (dvdNode, "HostDrive", &hostDriveNode);
-                CFGLDRSetBSTR (hostDriveNode, "src", name);
-                CFGLDRReleaseNode (hostDriveNode);
-                break;
-            }
-            case DriveState_NotMounted:
-                /* do nothing, i.e.leave the DVD drive node empty */
-                break;
-            default:
-                ComAssertMsgFailedBreak (("Invalid DVD drive state: %d\n",
-                                          mDVDDrive->data()->mDriveState),
-                                          rc = E_FAIL);
-        }
-
-        CFGLDRReleaseNode (dvdNode);
-    }
-    while (0);
-
+    rc = mDVDDrive->saveSettings (aNode);
     CheckComRCReturnRC (rc);
 
     /* Flooppy drive (required) */
-    /// @todo (dmik) move the code to DVDDrive
-    do
-    {
-        CFGNODE floppyNode = 0;
-        CFGLDRCreateChildNode (aNode, "FloppyDrive", &floppyNode);
-
-        BOOL fFloppyEnabled;
-        rc = mFloppyDrive->COMGETTER(Enabled)(&fFloppyEnabled);
-        CFGLDRSetBool (floppyNode, "enabled", !!fFloppyEnabled);
-
-        switch (mFloppyDrive->data()->mDriveState)
-        {
-            case DriveState_ImageMounted:
-            {
-                Assert (!mFloppyDrive->data()->mFloppyImage.isNull());
-
-                Guid id;
-                rc = mFloppyDrive->data()->mFloppyImage->COMGETTER(Id) (id.asOutParam());
-                Assert (!id.isEmpty());
-
-                CFGNODE imageNode = 0;
-                CFGLDRCreateChildNode (floppyNode, "Image", &imageNode);
-                CFGLDRSetUUID (imageNode, "uuid", id.ptr());
-                CFGLDRReleaseNode (imageNode);
-                break;
-            }
-            case DriveState_HostDriveCaptured:
-            {
-                Assert (!mFloppyDrive->data()->mHostDrive.isNull());
-
-                Bstr name;
-                rc = mFloppyDrive->data()->mHostDrive->COMGETTER(Name) (name.asOutParam());
-                Assert (!name.isEmpty());
-
-                CFGNODE hostDriveNode = 0;
-                CFGLDRCreateChildNode (floppyNode, "HostDrive", &hostDriveNode);
-                CFGLDRSetBSTR (hostDriveNode, "src", name);
-                CFGLDRReleaseNode (hostDriveNode);
-                break;
-            }
-            case DriveState_NotMounted:
-                /* do nothing, i.e.leave the Floppy drive node empty */
-                break;
-            default:
-                ComAssertMsgFailedBreak (("Invalid Floppy drive state: %d\n",
-                                          mFloppyDrive->data()->mDriveState),
-                                          rc = E_FAIL);
-        }
-
-        CFGLDRReleaseNode (floppyNode);
-    }
-    while (0);
-
+    rc = mFloppyDrive->saveSettings (aNode);
     CheckComRCReturnRC (rc);
-
 
     /* USB Controller (required) */
@@ -6546 +5600 @@
 
     /* Network adapters (required) */
-    do
-    {
-        CFGNODE nwNode = 0;
-        CFGLDRCreateChildNode (aNode, "Network", &nwNode);
-
-        for (ULONG slot = 0; slot < ELEMENTS (mNetworkAdapters); slot ++)
-        {
-            CFGNODE networkAdapterNode = 0;
-            CFGLDRAppendChildNode (nwNode, "Adapter", &networkAdapterNode);
-
-            CFGLDRSetUInt32 (networkAdapterNode, "slot", slot);
-            CFGLDRSetBool (networkAdapterNode, "enabled",
-                           !!mNetworkAdapters [slot]->data()->mEnabled);
-            CFGLDRSetBSTR (networkAdapterNode, "MACAddress",
-                           mNetworkAdapters [slot]->data()->mMACAddress);
-            CFGLDRSetBool (networkAdapterNode, "cable",
-                           !!mNetworkAdapters [slot]->data()->mCableConnected);
-
-            CFGLDRSetUInt32 (networkAdapterNode, "speed",
-                             mNetworkAdapters [slot]->data()->mLineSpeed);
-
-            if (mNetworkAdapters [slot]->data()->mTraceEnabled)
-                CFGLDRSetBool (networkAdapterNode, "trace", true);
-
-            CFGLDRSetBSTR (networkAdapterNode, "tracefile",
-                           mNetworkAdapters [slot]->data()->mTraceFile);
-
-            switch (mNetworkAdapters [slot]->data()->mAdapterType)
-            {
-                case NetworkAdapterType_NetworkAdapterAm79C970A:
-                    CFGLDRSetString (networkAdapterNode, "type", "Am79C970A");
-                    break;
-                case NetworkAdapterType_NetworkAdapterAm79C973:
-                    CFGLDRSetString (networkAdapterNode, "type", "Am79C973");
-                    break;
-                default:
-                    ComAssertMsgFailedBreak (("Invalid network adapter type: %d\n",
-                                              mNetworkAdapters [slot]->data()->mAdapterType),
-                                              rc = E_FAIL);
-            }
-
-            CFGNODE attachmentNode = 0;
-            switch (mNetworkAdapters [slot]->data()->mAttachmentType)
-            {
-                case NetworkAttachmentType_NoNetworkAttachment:
-                {
-                    /* do nothing -- empty content */
-                    break;
-                }
-                case NetworkAttachmentType_NATNetworkAttachment:
-                {
-                    CFGLDRAppendChildNode (networkAdapterNode, "NAT", &attachmentNode);
-                    break;
-                }
-                case NetworkAttachmentType_HostInterfaceNetworkAttachment:
-                {
-                    CFGLDRAppendChildNode (networkAdapterNode, "HostInterface", &attachmentNode);
-                    const Bstr &name = mNetworkAdapters [slot]->data()->mHostInterface;
-#ifdef RT_OS_WINDOWS
-                    Assert (!name.isNull());
-#endif
-#ifdef VBOX_WITH_UNIXY_TAP_NETWORKING
-                    if (!name.isEmpty())
-#endif
-                        CFGLDRSetBSTR (attachmentNode, "name", name);
-#ifdef VBOX_WITH_UNIXY_TAP_NETWORKING
-                    const Bstr &tapSetupApp =
-                        mNetworkAdapters [slot]->data()->mTAPSetupApplication;
-                    if (!tapSetupApp.isEmpty())
-                        CFGLDRSetBSTR (attachmentNode, "TAPSetup", tapSetupApp);
-                    const Bstr &tapTerminateApp =
-                        mNetworkAdapters [slot]->data()->mTAPTerminateApplication;
-                    if (!tapTerminateApp.isEmpty())
-                        CFGLDRSetBSTR (attachmentNode, "TAPTerminate", tapTerminateApp);
-#endif /* VBOX_WITH_UNIXY_TAP_NETWORKING */
-                    break;
-                }
-                case NetworkAttachmentType_InternalNetworkAttachment:
-                {
-                    CFGLDRAppendChildNode (networkAdapterNode, "InternalNetwork", &attachmentNode);
-                    const Bstr &name = mNetworkAdapters[slot]->data()->mInternalNetwork;
-                    Assert(!name.isNull());
-                    CFGLDRSetBSTR (attachmentNode, "name", name);
-                    break;
-                }
-                default:
-                {
-                    ComAssertFailedBreak (rc = E_FAIL);
-                    break;
-                }
-            }
-            if (attachmentNode)
-                CFGLDRReleaseNode (attachmentNode);
-
-            CFGLDRReleaseNode (networkAdapterNode);
-        }
-
-        CFGLDRReleaseNode (nwNode);
-    }
-    while (0);
-
-    if (FAILED (rc))
-        return rc;
+    {
+        Key nwNode = aNode.createKey ("Network");
+
+        for (ULONG slot = 0; slot < ELEMENTS (mNetworkAdapters); ++ slot)
+        {
+            Key adapterNode = nwNode.appendKey ("Adapter");
+
+            adapterNode.setValue <ULONG> ("slot", slot);
+
+            rc = mNetworkAdapters [slot]->saveSettings (adapterNode);
+            CheckComRCReturnRC (rc);
+        }
+    }
 
     /* Serial ports */
-    CFGNODE serialNode = 0;
-    CFGLDRCreateChildNode (aNode, "Uart", &serialNode);
-
-    for (ULONG slot = 0; slot < ELEMENTS (mSerialPorts); slot++)
-    {
-        rc = mSerialPorts [slot]->saveSettings (serialNode);
-        CheckComRCReturnRC (rc);
-    }
-    CFGLDRReleaseNode (serialNode);
+    {
+        Key serialNode = aNode.createKey ("Uart");
+        for (ULONG slot = 0; slot < ELEMENTS (mSerialPorts); ++ slot)
+        {
+            Key portNode = serialNode.appendKey ("Port");
+
+            portNode.setValue <ULONG> ("slot", slot);
+
+            rc = mSerialPorts [slot]->saveSettings (portNode);
+            CheckComRCReturnRC (rc);
+        }
+    }
 
     /* Parallel ports */
-    CFGNODE parallelNode = 0;
-    CFGLDRCreateChildNode (aNode, "Lpt", &parallelNode);
-
-    for (ULONG slot = 0; slot < ELEMENTS (mParallelPorts); slot++)
-    {
-        rc = mParallelPorts [slot]->saveSettings (parallelNode);
-        CheckComRCReturnRC (rc);
-    }
-    CFGLDRReleaseNode (parallelNode);
+    {
+        Key parallelNode = aNode.createKey ("Lpt");
+        for (ULONG slot = 0; slot < ELEMENTS (mParallelPorts); ++ slot)
+        {
+            Key portNode = parallelNode.appendKey ("Port");
+
+            portNode.setValue <ULONG> ("slot", slot);
+
+            rc = mParallelPorts [slot]->saveSettings (portNode);
+            CheckComRCReturnRC (rc);
+        }
+    }
 
     /* Audio adapter */
-    do
-    {
-        CFGNODE adapterNode = 0;
-        CFGLDRCreateChildNode (aNode, "AudioAdapter", &adapterNode);
-
-        switch (mAudioAdapter->data()->mAudioDriver)
-        {
-            case AudioDriverType_NullAudioDriver:
-            {
-                CFGLDRSetString (adapterNode, "driver", "null");
-                break;
-            }
-#ifdef RT_OS_WINDOWS
-            case AudioDriverType_WINMMAudioDriver:
-# ifdef VBOX_WITH_WINMM
-            {
-                CFGLDRSetString (adapterNode, "driver", "winmm");
-                break;
-            }
-# endif
-            case AudioDriverType_DSOUNDAudioDriver:
-            {
-                CFGLDRSetString (adapterNode, "driver", "dsound");
-                break;
-            }
-#endif /* RT_OS_WINDOWS */
-#ifdef RT_OS_LINUX
-            case AudioDriverType_ALSAAudioDriver:
-# ifdef VBOX_WITH_ALSA
-            {
-                CFGLDRSetString (adapterNode, "driver", "alsa");
-                break;
-            }
-# endif
-# ifdef VBOX_WITH_PULSE
-            case AudioDriverType_PulseAudioDriver:
-            {
-                CFGLDRSetString (adapterNode, "driver", "pulse");
-                break;
-            }
-# endif
-            case AudioDriverType_OSSAudioDriver:
-            {
-                CFGLDRSetString (adapterNode, "driver", "oss");
-                break;
-            }
-#endif /* RT_OS_LINUX */
-#ifdef RT_OS_DARWIN
-            case AudioDriverType_CoreAudioDriver:
-            {
-                CFGLDRSetString (adapterNode, "driver", "coreaudio");
-                break;
-            }
-#endif
-#ifdef RT_OS_OS2
-            case AudioDriverType_MMPMAudioDriver:
-            {
-                CFGLDRSetString (adapterNode, "driver", "mmpm");
-                break;
-            }
-#endif
-            default:
-                ComAssertMsgFailedBreak (("Wrong audio driver type! driver = %d\n",
-                                          mAudioAdapter->data()->mAudioDriver),
-                                          rc = E_FAIL);
-        }
-
-        CFGLDRSetBool (adapterNode, "enabled", !!mAudioAdapter->data()->mEnabled);
-
-        CFGLDRReleaseNode (adapterNode);
-    }
-    while (0);
-
-    if (FAILED (rc))
-        return rc;
+    rc = mAudioAdapter->saveSettings (aNode);
+    CheckComRCReturnRC (rc);
 
     /* Shared folders */
-    do
-    {
-        CFGNODE sharedFoldersNode = 0;
-        CFGLDRCreateChildNode (aNode, "SharedFolders", &sharedFoldersNode);
+    {
+        Key sharedFoldersNode = aNode.createKey ("SharedFolders");
 
         for (HWData::SharedFolderList::const_iterator it = mHWData->mSharedFolders.begin();
@@ -6761 +5656 @@
             ComObjPtr <SharedFolder> folder = *it;
 
-            CFGNODE folderNode = 0;
-            CFGLDRAppendChildNode (sharedFoldersNode, "SharedFolder", &folderNode);
+            Key folderNode = sharedFoldersNode.appendKey ("SharedFolder");
 
             /* all are mandatory */
-            CFGLDRSetBSTR (folderNode, "name", folder->name());
-            CFGLDRSetBSTR (folderNode, "hostPath", folder->hostPath());
-
-            CFGLDRReleaseNode (folderNode);
-        }
-
-        CFGLDRReleaseNode (sharedFoldersNode);
-    }
-    while (0);
+            folderNode.setValue <Bstr> ("name", folder->name());
+            folderNode.setValue <Bstr> ("hostPath", folder->hostPath());
+        }
+    }
 
     /* Clipboard */
     {
-        CFGNODE clipNode = 0;
-        CFGLDRCreateChildNode (aNode, "Clipboard", &clipNode);
-
-        const char *mode = "Disabled";
+        Key clipNode = aNode.createKey ("Clipboard");
+
+        const char *modeStr = "Disabled";
         switch (mHWData->mClipboardMode)
         {
@@ -6787 +5675 @@
                 break;
             case ClipboardMode_ClipHostToGuest:
-                mode = "HostToGuest";
+                modeStr = "HostToGuest";
                 break;
             case ClipboardMode_ClipGuestToHost:
-                mode = "GuestToHost";
+                modeStr = "GuestToHost";
                 break;
             case ClipboardMode_ClipBidirectional:
-                mode = "Bidirectional";
+                modeStr = "Bidirectional";
                 break;
             default:
-                AssertMsgFailed (("Clipboard mode %d is invalid",
-                                  mHWData->mClipboardMode));
-                break;
-        }
-        CFGLDRSetString (clipNode, "mode", mode);
-
-        CFGLDRReleaseNode (clipNode);
+                ComAssertMsgFailedRet (("Clipboard mode %d is invalid",
+                                        mHWData->mClipboardMode),
+                                       E_FAIL);
+        }
+        clipNode.setStringValue ("mode", modeStr);
     }
 
     /* Guest */
     {
-        CFGNODE guestNode = 0;
-        CFGLDRGetChildNode (aNode, "Guest", 0, &guestNode);
+        Key guestNode = aNode.findKey ("Guest");
         /* first, delete the entire node if exists */
-        if (guestNode)
-            CFGLDRDeleteNode (guestNode);
+        if (!guestNode.isNull())
+            guestNode.zap();
         /* then recreate it */
-        guestNode = 0;
-        CFGLDRCreateChildNode (aNode, "Guest", &guestNode);
-
-        CFGLDRSetUInt32 (guestNode, "MemoryBalloonSize",
-                         mHWData->mMemoryBalloonSize);
-        CFGLDRSetUInt32 (guestNode, "StatisticsUpdateInterval",
-                         mHWData->mStatisticsUpdateInterval);
-
-        CFGLDRReleaseNode (guestNode);
-    }
-
+        guestNode = aNode.createKey ("Guest");
+
+        guestNode.setValue <ULONG> ("MemoryBalloonSize",
+                                    mHWData->mMemoryBalloonSize);
+        guestNode.setValue <ULONG> ("StatisticsUpdateInterval",
+                                    mHWData->mStatisticsUpdateInterval);
+    }
+
+    AssertComRC (rc);
     return rc;
 }
@@ -6831 +5714 @@
  *  It is assumed that the given node is empty.
  *
- *  @param aNode    <HardDiskAttachments> node to save the hard disk confguration to
+ *  @param aNode    <HardDiskAttachments> node to save the hard disk confguration to.
  */
-HRESULT Machine::saveHardDisks (CFGNODE aNode)
-{
-    AssertReturn (aNode, E_INVALIDARG);
-
-    HRESULT rc = S_OK;
+HRESULT Machine::saveHardDisks (settings::Key &aNode)
+{
+    using namespace settings;
+
+    AssertReturn (!aNode.isNull(), E_INVALIDARG);
 
     for (HDData::HDAttachmentList::const_iterator it = mHDData->mHDAttachments.begin();
-         it != mHDData->mHDAttachments.end() && SUCCEEDED (rc);
+         it != mHDData->mHDAttachments.end();
          ++ it)
     {
         ComObjPtr <HardDiskAttachment> att = *it;
 
-        CFGNODE hdNode = 0;
-        CFGLDRAppendChildNode (aNode, "HardDiskAttachment", &hdNode);
-
-        do
+        Key hdNode = aNode.appendKey ("HardDiskAttachment");
+
         {
             const char *bus = NULL;
@@ -6856 +5737 @@
                 case DiskControllerType_IDE1Controller: bus = "ide1"; break;
                 default:
-                    ComAssertFailedBreak (rc = E_FAIL);
+                    ComAssertFailedRet (E_FAIL);
             }
-            if (FAILED (rc))
-                break;
 
             const char *dev = NULL;
@@ -6867 +5746 @@
                 case 1: dev = "slave"; break;
                 default:
-                    ComAssertFailedBreak (rc = E_FAIL);
+                    ComAssertFailedRet (E_FAIL);
             }
-            if (FAILED (rc))
-                break;
-
-            CFGLDRSetUUID (hdNode, "hardDisk", att->hardDisk()->id());
-            CFGLDRSetString (hdNode, "bus", bus);
-            CFGLDRSetString (hdNode, "device", dev);
-        }
-        while (0);
-
-        CFGLDRReleaseNode (hdNode);
-    }
-
-    return rc;
+
+            hdNode.setValue <Guid> ("hardDisk", att->hardDisk()->id());
+            hdNode.setStringValue ("bus", bus);
+            hdNode.setStringValue ("device", dev);
+        }
+    }
+
+    return S_OK;
 }
 
@@ -6888 +5762 @@
  *  (SaveSTS_* values).
  *
- *  @param aFlags   a combination of SaveSTS_* flags
- *
- *  @note Locks objects!
+ *  @param aFlags   Combination of SaveSTS_* flags.
+ *
+ *  @note Locks objects for writing.
  */
 HRESULT Machine::saveStateSettings (int aFlags)
@@ -6902 +5776 @@
     AutoLock alock (this);
 
-    /* load the config file */
-    CFGHANDLE configLoader = 0;
-    HRESULT rc = openConfigLoader (&configLoader);
-    if (FAILED (rc))
-        return rc;
-
-    CFGNODE machineNode = 0;
-    CFGLDRGetNode (configLoader, "VirtualBox/Machine", 0, &machineNode);
-
-    do
-    {
-        ComAssertBreak (machineNode, rc = E_FAIL);
+    AssertReturn (isConfigLocked(), E_FAIL);
+
+    HRESULT rc = S_OK;
+
+    try
+    {
+        using namespace settings;
+
+        /* load the config file */
+        File file (File::ReadWrite, mData->mHandleCfgFile,
+                   Utf8Str (mData->mConfigFileFull));
+        XmlTreeBackend tree;
+
+        rc = VirtualBox::loadSettingsTree_ForUpdate (tree, file);
+        CheckComRCReturnRC (rc);
+
+        Key machineNode = tree.rootKey().key ("Machine");
 
         if (aFlags & SaveSTS_CurStateModified)
         {
-            if (!mData->mCurrentStateModified)
-                CFGLDRSetBool (machineNode, "currentStateModified", false);
-            else
-                CFGLDRDeleteAttribute (machineNode, "currentStateModified");
+            /* defaults to true */
+            machineNode.setValueOr <bool> ("currentStateModified",
+                                           !mData->mCurrentStateModified, true);
         }
 
@@ -6930 +5808 @@
                 Utf8Str stateFilePath = mSSData->mStateFilePath;
                 calculateRelativePath (stateFilePath, stateFilePath);
-                CFGLDRSetString (machineNode, "stateFile", stateFilePath);
+                machineNode.setStringValue ("stateFile", stateFilePath);
             }
             else
-                CFGLDRDeleteAttribute (machineNode, "stateFile");
+                machineNode.zapValue ("stateFile");
         }
 
@@ -6941 +5819 @@
                     mSSData->mStateFilePath.isNull());
 
-            CFGLDRSetDateTime (machineNode, "lastStateChange",
-                               mData->mLastStateChange);
-
-            // set the aborted attribute when appropriate
-            if (mData->mMachineState == MachineState_Aborted)
-                CFGLDRSetBool (machineNode, "aborted", true);
-            else
-                CFGLDRDeleteAttribute (machineNode, "aborted");
-        }
-    }
-    while (0);
-
-    if (machineNode)
-        CFGLDRReleaseNode (machineNode);
-
-    if (SUCCEEDED (rc))
-        rc = closeConfigLoader (configLoader, true /* aSaveBeforeClose */);
-    else
-        closeConfigLoader (configLoader, false /* aSaveBeforeClose */);
+            machineNode.setValue <RTTIMESPEC> ("lastStateChange",
+                                               mData->mLastStateChange);
+
+            /* set the aborted attribute when appropriate, defaults to false */
+            machineNode.setValueOr <bool> ("aborted",
+                                           mData->mMachineState == MachineState_Aborted,
+                                           false);
+        }
+
+        /* save settings on success */
+        rc = VirtualBox::saveSettingsTree (tree, file);
+        CheckComRCReturnRC (rc);
+    }
+    catch (...)
+    {
+        rc = VirtualBox::handleUnexpectedExceptions (RT_SRC_POS);
+    }
 
     return rc;
@@ -8947 +7823 @@
     snapshot.createObject();
     rc = snapshot->init (snapshotId, aName, aDescription,
-                         RTTimeSpecGetMilli (RTTimeNow (&time)),
-                         snapshotMachine, mData->mCurrentSnapshot);
-    AssertComRCReturn (rc, rc);
+                         *RTTimeNow (&time), snapshotMachine,
+                         mData->mCurrentSnapshot);
+    AssertComRCReturnRC (rc);
 
     /*
@@ -9631 +8507 @@
     AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
 
-    /* mParent->removeProgress() needs mParent lock */
+    /* mParent->removeProgress() and saveSettings() need mParent lock */
     AutoMultiLock <2> alock (mParent->wlock(), this->wlock());
 
@@ -9877 +8753 @@
     ComObjPtr <SnapshotMachine> sm = aTask.snapshot->data().mMachine;
 
-    /* mParent is locked because of Progress::notifyComplete(), etc. */
+    /* Progress::notifyComplete() et al., saveSettings() need mParent lock */
     AutoMultiLock <3> alock (mParent->wlock(), this->wlock(), sm->rlock());
 
@@ -10269 +9145 @@
     }
 
-    /* mParent is locked because of Progress::notifyComplete(), etc. */
+    /* Progress::notifyComplete() et al., saveSettings() need mParent lock */
     AutoMultiLock <2> alock (mParent->wlock(), this->wlock());
 
@@ -10328 +9204 @@
         }
 
-        LONG64 snapshotTimeStamp = 0;
+        RTTIMESPEC snapshotTimeStamp;
+        RTTimeSpecSetMilli (&snapshotTimeStamp, 0);
 
         {
@@ -10462 +9339 @@
 
         /* assign the timestamp from the snapshot */
-        Assert (snapshotTimeStamp != 0);
+        Assert (RTTimeSpecGetMilli (&snapshotTimeStamp) != 0);
         mData->mLastStateChange = snapshotTimeStamp;
 
@@ -10879 +9756 @@
  *  @note Locks aMachine object for reading.
  */
-HRESULT SnapshotMachine::init (Machine *aMachine, CFGNODE aHWNode, CFGNODE aHDAsNode,
+HRESULT SnapshotMachine::init (Machine *aMachine,
+                               const settings::Key &aHWNode,
+                               const settings::Key &aHDAsNode,
                                INPTR GUIDPARAM aSnapshotId, INPTR BSTR aStateFilePath)
 {
@@ -10885 +9764 @@
     LogFlowThisFunc (("mName={%ls}\n", aMachine->mUserData->mName.raw()));
 
-    AssertReturn (aMachine && aHWNode && aHDAsNode && !Guid (aSnapshotId).isEmpty(),
+    AssertReturn (aMachine && !aHWNode.isNull() && !aHDAsNode.isNull() &&
+                  !Guid (aSnapshotId).isEmpty(),
                   E_INVALIDARG);
 

trunk/src/VBox/Main/Makefile.kmk

@@ -1 +1 @@
 # $Id$
+
 ## @file
 # Makefile for the VBox Main module.
@@ -27 +28 @@
 
 LIBRARIES        = VBoxCOM
-DLLS             = VBoxXML VBoxC
+DLLS             = VBoxXML VBoxSettings VBoxC
 PROGRAMS         = VBoxSVC
 ifneq ($(BUILD_TARGET),win)
@@ -101 +102 @@
 
 VBoxSVC_TEMPLATE = VBOXMAINEXE
-VBoxSVC_DEFS = CFGLDR_HAVE_COM IN_CFGLDR_R3
+VBoxSVC_DEFS = CFGLDR_HAVE_COM IN_CFGLDR_R3 VBOX_MAIN_SETTINGS_ADDONS
 ifdef VBOX_WITH_VRDP
 VBoxSVC_DEFS += VBOX_VRDP
@@ -139 +140 @@
         include \
         $(PATH_VBoxSVC) \
-        $(PATH_VBoxCOM) \
         $(PATH_CURRENT)
+VBoxSVC_INCS.win = \
+        $(PATH_VBoxCOM)
 ifdef VBOX_WITH_USB
  VBoxSVC_INCS.os2 = \
@@ -149 +151 @@
  VBoxSVC_LIBS += \
         $(PATH_LIB)/VBoxDDU$(VBOX_SUFF_LIB) \
-        $(PATH_LIB)/VBoxXML$(VBOX_SUFF_LIB)
+        $(PATH_LIB)/VBoxXML$(VBOX_SUFF_LIB) \
+        $(PATH_LIB)/VBoxSettings$(VBOX_SUFF_LIB)
 else
  VBoxSVC_LIBS += \
         $(PATH_BIN)/VBoxDDU$(VBOX_SUFF_DLL) \
-        $(PATH_BIN)/VBoxXML$(VBOX_SUFF_DLL)
+        $(PATH_BIN)/VBoxXML$(VBOX_SUFF_DLL) \
+        $(PATH_BIN)/VBoxSettings$(VBOX_SUFF_DLL)
 endif
 VBoxSVC_LIBS.darwin = \
@@ -167 +171 @@
         USBProxyService.cpp \
         VirtualBoxBase.cpp \
-        VirtualBoxXMLUtil.cpp \
         VirtualBoxErrorInfoImpl.cpp \
         VirtualBoxImpl.cpp \
+        VirtualBoxImplExtra.cpp \
         MachineImpl.cpp \
         SnapshotImpl.cpp \
@@ -314 +318 @@
 VBoxC_INCS          = \
         include \
-        $(PATH_VBoxC) \
-        $(PATH_VBoxCOM)
-VBoxC_INCS.win     := \
+        $(PATH_VBoxC)
+VBoxC_INCS.win      = \
+        $(PATH_VBoxCOM) \
         $(PATH_SUB_CURRENT)
 
@@ -323 +327 @@
         -exported_symbols_list $(PATH_TARGET)/VBoxC.def
 ifdef VBOX_USE_VCC80
-VBoxC_LDFLAGS.win = /MANIFEST
+ VBoxC_LDFLAGS.win = /MANIFEST
 endif
 
@@ -395 +399 @@
 # VBoxXML
 #
+
 VBoxXML_TEMPLATE   = VBOXMAINDLL
 VBoxXML_SDKS       = VBOX_XALAN VBOX_XERCES
@@ -419 +424 @@
         $(call MSG_TOOL,bin2c,VBoxXML,$<,$@)
         $(QUIET)$(VBOX_BIN2C) SettingsConverter_xsl $< $@
+
+
+#
+# VBoxSettings (will supercede VBoxXML when done)
+#
+
+VBoxSettings_TEMPLATE   = VBOXMAINDLL
+VBoxSettings_SDKS       = VBOX_LIBXML2 VBOX_ZLIB
+VBoxSettings_DEFS       = IN_VBOXSETTINGS_R3
+VBoxSettings_INCS       = \
+        include \
+        $(PATH_TARGET)
+VBoxSettings_SOURCES    = \
+        xml/Settings.cpp
+VBoxSettings_LDFLAGS.darwin = -install_name @executable_path/VBoxSettings.dylib -Wl,-x # no debug info please.
 
 
@@ -494 +514 @@
 VBOX_XML_SCHEMA.solaris= xml/VirtualBox-settings-solaris.xsd
 
-VirtualBoxXMLUtil.cpp_DEPS = $(VBOX_XML_ENTITIES) $(VBOX_XML_ENTITIES_COMMON)
+VirtualBoxImplExtra.cpp_DEPS = $(VBOX_XML_ENTITIES) $(VBOX_XML_ENTITIES_COMMON)
 
 $(VBOX_XML_ENTITIES_COMMON): $(VBOX_XML_SCHEMA_COMMON) $(VBOX_BIN2C)
-        $(call MSG_TOOL,bin2c,VBoxXML,$<,$@)
+        $(call MSG_TOOL,bin2c,VBoxSVC,$<,$@)
         $(QUIET)$(VBOX_BIN2C) VirtualBox_settings_common_xsd $< $@
 
 $(VBOX_XML_ENTITIES): $(VBOX_XML_SCHEMA.$(BUILD_TARGET)) $(VBOX_BIN2C)
-        $(call MSG_TOOL,bin2c,VBoxXML,$<,$@)
+        $(call MSG_TOOL,bin2c,VBoxSVC,$<,$@)
         $(QUIET)$(VBOX_BIN2C) VirtualBox_settings_xsd $< $@
 
@@ -519 +539 @@
 
 $(VBOX_XML_SCHEMADEFS_H): $(VBOX_XML_SCHEMADEFS_XSL) $(VBOX_XML_SCHEMA.$(BUILD_TARGET)) $(VBOX_XML_SCHEMA_COMMON)
-        $(call MSG_TOOL,xsltproc,VBoxXML,$<,$@)
+        $(call MSG_TOOL,xsltproc,VBoxSVC,$<,$@)
         $(QUIET)$(VBOX_XSLTPROC) -o $@ $(filter-out $(VBOX_XML_SCHEMA_COMMON),$^)
 
@@ -556 +576 @@
 
 $(IDLFILE): idl/xpidl.xsl $(XIDLFILE) | $(call DIRDEP,$(dir $(IDLFILE)))
-        $(call MSG_TOOL,xsltproc,VBoxXML,$<,$@)
+        $(call MSG_TOOL,xsltproc,VBoxSVC,$<,$@)
         $(QUIET)$(MKDIR) -p $(@D)
         $(QUIET)$(VBOX_XSLTPROC) -o $@ $^
 
 $(IDLTYPELIB): $(IDLFILE) | $(call DIRDEP,$(dir $(IDLTYPELIB)))
-        $(call MSG_TOOL,xpidl,VBoxXML,$<,$@)
+        $(call MSG_TOOL,xpidl,VBoxSVC,$<,$@)
         $(QUIET)$(VBOX_XPIDL) -m typelib -I $(VBOX_PATH_XPCOM_IDL) -e $@ $<
 
 $(IDLHEADER): $(IDLFILE) | $(call DIRDEP,$(dir $(IDLHEADER)))
-        $(call MSG_TOOL,xpidl,VBoxXML,$<,$@)
+        $(call MSG_TOOL,xpidl,VBoxSVC,$<,$@)
         $(QUIET)$(VBOX_XPIDL) -m header  -I $(VBOX_PATH_XPCOM_IDL) -e $@ $<
 
@@ -581 +601 @@
 
 $(IDLFILE): idl/midl.xsl $(XIDLFILE)
-        $(call MSG_TOOL,xsltproc,VBoxXML,$<,$@)
+        $(call MSG_TOOL,xsltproc,VBoxSVC,$<,$@)
         $(QUIET)$(MKDIR) -p $(VBOX_PATH_SDK)/idl
         $(QUIET)$(VBOX_XSLTPROC) -o $@ $^

trunk/src/VBox/Main/NetworkAdapterImpl.cpp

@@ -935 +935 @@
 // public methods only for internal purposes
 ////////////////////////////////////////////////////////////////////////////////
+
+/**
+ *  Loads settings from the given adapter node.
+ *  May be called once right after this object creation.
+ * 
+ *  @param aAdapterNode <Adapter> node.
+ * 
+ *  @note Locks this object for writing. 
+ */
+HRESULT NetworkAdapter::loadSettings (const settings::Key &aAdapterNode)
+{
+    using namespace settings;
+
+    AssertReturn (!aAdapterNode.isNull(), E_FAIL);
+
+    AutoCaller autoCaller (this);
+    AssertComRCReturnRC (autoCaller.rc());
+
+    AutoLock alock (this);
+
+    /* Note: we assume that the default values for attributes of optional
+     * nodes are assigned in the Data::Data() constructor and don't do it
+     * here. It implies that this method may only be called after constructing
+     * a new BIOSSettings object while all its data fields are in the default
+     * values. Exceptions are fields whose creation time defaults don't match
+     * values that should be applied when these fields are not explicitly set
+     * in the settings file (for backwards compatibility reasons). This takes
+     * place when a setting of a newly created object must default to A while
+     * the same setting of an object loaded from the old settings file must
+     * default to B. */ 
+
+    HRESULT rc = S_OK;
+
+    /* type (optional, defaults to Am79C970A) */
+    const char *adapterType = aAdapterNode.stringValue ("type");
+
+    if (strcmp (adapterType, "Am79C970A") == 0)
+        mData->mAdapterType = NetworkAdapterType_NetworkAdapterAm79C970A;
+    else if (strcmp (adapterType, "Am79C973") == 0)
+        mData->mAdapterType = NetworkAdapterType_NetworkAdapterAm79C973;
+    else
+        ComAssertMsgFailedRet (("Invalid adapter type '%s'", adapterType),
+                               E_FAIL);
+
+    /* enabled (required) */
+    mData->mEnabled = aAdapterNode.value <bool> ("enabled");
+    /* MAC address (can be null) */
+    rc = COMSETTER(MACAddress) (Bstr (aAdapterNode.stringValue ("MACAddress")));
+    CheckComRCReturnRC (rc);
+    /* cable (required) */
+    mData->mCableConnected = aAdapterNode.value <bool> ("cable");
+    /* line speed (defaults to 100 Mbps) */
+    mData->mLineSpeed = aAdapterNode.value <ULONG> ("speed");
+    /* tracing (defaults to false) */
+    mData->mTraceEnabled = aAdapterNode.value <bool> ("trace");
+    mData->mTraceFile = aAdapterNode.stringValue ("tracefile");
+
+    /* One of NAT, HostInerface, Internal or nothing */
+    Key attachmentNode;
+
+    if (!(attachmentNode = aAdapterNode.findKey ("NAT")).isNull())
+    {
+        /* NAT */
+
+        rc = AttachToNAT();
+        CheckComRCReturnRC (rc);
+    }
+    else
+    if (!(attachmentNode = aAdapterNode.findKey ("HostInerface")).isNull())
+    {
+        /* Host Interface Networking */
+
+        Bstr name = attachmentNode.stringValue ("name");
+#ifdef RT_OS_WINDOWS
+        /* name can be empty on Win32, but not null */
+        ComAssertRet (!name.isNull(), E_FAIL);
+#endif
+        rc = COMSETTER(HostInterface) (name);
+        CheckComRCReturnRC (rc);
+
+#ifdef VBOX_WITH_UNIXY_TAP_NETWORKING
+        /* optopnal */
+        mData->mTAPSetupApplication = attachmentNode.stringValue ("TAPSetup");
+        mData->mTAPTerminateApplication = attachmentNode.stringValue ("TAPTerminate");
+#endif /* VBOX_WITH_UNIXY_TAP_NETWORKING */
+
+        rc = AttachToHostInterface();
+        CheckComRCReturnRC (rc);
+    }
+    else
+    if (!(attachmentNode = aAdapterNode.findKey ("InternalNetwork")).isNull())
+    {
+        /* Internal Networking */
+
+        /* required */
+        mData->mInternalNetwork = attachmentNode.stringValue ("name");
+
+        rc = AttachToInternalNetwork();
+        CheckComRCReturnRC (rc);
+    }
+    else
+    {
+        /* Adapter has no children */
+        rc = Detach();
+        CheckComRCReturnRC (rc);
+    }
+
+    return S_OK;
+}
+
+/** 
+ *  Saves settings to the given adapter node.
+ * 
+ *  Note that the given Adapter node is comletely empty on input.
+ *
+ *  @param aAdapterNode <Adapter> node.
+ * 
+ *  @note Locks this object for reading. 
+ */
+HRESULT NetworkAdapter::saveSettings (settings::Key &aAdapterNode)
+{
+    using namespace settings;
+
+    AssertReturn (!aAdapterNode.isNull(), E_FAIL);
+
+    AutoCaller autoCaller (this);
+    AssertComRCReturnRC (autoCaller.rc());
+
+    AutoReaderLock alock (this);
+
+    aAdapterNode.setValue <bool> ("enabled", !!mData->mEnabled);
+    aAdapterNode.setValue <Bstr> ("MACAddress", mData->mMACAddress);
+    aAdapterNode.setValue <bool> ("cable", !!mData->mCableConnected);
+
+    aAdapterNode.setValue <ULONG> ("speed", mData->mLineSpeed);
+
+    if (mData->mTraceEnabled)
+        aAdapterNode.setValue <bool> ("trace", true);
+
+    aAdapterNode.setValueOr <Bstr> ("tracefile", mData->mTraceFile, Bstr::Null);
+
+    const char *typeStr = NULL;
+    switch (mData->mAdapterType)
+    {
+        case NetworkAdapterType_NetworkAdapterAm79C970A:
+            typeStr = "Am79C970A";
+            break;
+        case NetworkAdapterType_NetworkAdapterAm79C973:
+            typeStr = "Am79C973";
+            break;
+        default:
+            ComAssertMsgFailedRet (("Invalid network adapter type: %d\n",
+                                    mData->mAdapterType),
+                                   E_FAIL);
+    }
+    aAdapterNode.setStringValue ("type", typeStr);
+
+    switch (mData->mAttachmentType)
+    {
+        case NetworkAttachmentType_NoNetworkAttachment:
+        {
+            /* do nothing -- empty content */
+            break;
+        }
+        case NetworkAttachmentType_NATNetworkAttachment:
+        {
+            Key attachmentNode = aAdapterNode.createKey ("NAT");
+            break;
+        }
+        case NetworkAttachmentType_HostInterfaceNetworkAttachment:
+        {
+            Key attachmentNode = aAdapterNode.createKey ("HostInterface");
+#ifdef RT_OS_WINDOWS
+            Assert (!mData->mHostInterface.isNull());
+#endif
+#ifdef VBOX_WITH_UNIXY_TAP_NETWORKING
+            if (!mData->mHostInterface.isEmpty())
+#endif
+                attachmentNode.setValue <Bstr> ("name", mData->mHostInterface);
+#ifdef VBOX_WITH_UNIXY_TAP_NETWORKING
+            if (!mData->mTAPSetupApplication.isEmpty())
+                attachmentNode.setValue <Bstr> ("TAPSetup",
+                                                mData->mTAPSetupApplication);
+            if (!mData->mTAPTerminateApplication.isEmpty())
+                attachmentNode.setValue <Bstr> ("TAPTerminate",
+                                                mData->mTAPTerminateApplication);
+#endif /* VBOX_WITH_UNIXY_TAP_NETWORKING */
+            break;
+        }
+        case NetworkAttachmentType_InternalNetworkAttachment:
+        {
+            Key attachmentNode = aAdapterNode.createKey ("InternalNetwork");
+            Assert (!mData->mInternalNetwork.isNull());
+            attachmentNode.setValue <Bstr> ("name", mData->mInternalNetwork);
+            break;
+        }
+        default:
+        {
+            ComAssertFailedRet (E_FAIL);
+        }
+    }
+
+    return S_OK;
+}
 
 /**

trunk/src/VBox/Main/ParallelPortImpl.cpp

@@ -161 +161 @@
 
 /**
+ *  Loads settings from the given port node.
+ *  May be called once right after this object creation.
+ * 
+ *  @param aPortNode <Port> node.
+ * 
+ *  @note Locks this object for writing.
+ */
+HRESULT ParallelPort::loadSettings (const settings::Key &aPortNode)
+{
+    using namespace settings;
+
+    AssertReturn (!aPortNode.isNull(), E_FAIL);
+
+    AutoCaller autoCaller (this);
+    AssertComRCReturnRC (autoCaller.rc());
+
+    AutoLock alock (this);
+
+    /* Note: we assume that the default values for attributes of optional
+     * nodes are assigned in the Data::Data() constructor and don't do it
+     * here. It implies that this method may only be called after constructing
+     * a new BIOSSettings object while all its data fields are in the default
+     * values. Exceptions are fields whose creation time defaults don't match
+     * values that should be applied when these fields are not explicitly set
+     * in the settings file (for backwards compatibility reasons). This takes
+     * place when a setting of a newly created object must default to A while
+     * the same setting of an object loaded from the old settings file must
+     * default to B. */ 
+
+    /* enabled (required) */
+    mData->mEnabled = aPortNode.value <bool> ("enabled");
+    /* I/O base (required) */
+    mData->mIOBase = aPortNode.value <ULONG> ("IOBase");
+    /* IRQ (required) */
+    mData->mIRQ = aPortNode.value <ULONG> ("IRQ");
+    /* device path (may be null) */
+    /// @todo report an error if enabled is true and path is empty or null!
+    //  The same applies to COMSETTER(Path).
+    mData->mPath = aPortNode.stringValue ("path");
+
+    return S_OK;
+}
+
+/** 
+ *  Saves settings to the given port node.
+ * 
+ *  Note that the given Port node is comletely empty on input.
+ *
+ *  @param aPortNode <Port> node.
+ * 
+ *  @note Locks this object for reading. 
+ */
+HRESULT ParallelPort::saveSettings (settings::Key &aPortNode)
+{
+    using namespace settings;
+
+    AssertReturn (!aPortNode.isNull(), E_FAIL);
+
+    AutoCaller autoCaller (this);
+    AssertComRCReturnRC (autoCaller.rc());
+
+    AutoReaderLock alock (this);
+
+    aPortNode.setValue <bool> ("enabled", !!mData->mEnabled);
+    aPortNode.setValue <ULONG> ("IOBase", mData->mIOBase, 16);
+    aPortNode.setValue <ULONG> ("IRQ", mData->mIRQ);
+
+    /* 'path' is optional in XML */
+    if (!mData->mPath.isEmpty())
+        aPortNode.setValue <Bstr> ("path", mData->mPath);
+
+    return S_OK;
+}
+
+/**
  *  @note Locks this object for writing.
  */
@@ -233 +308 @@
     /* this will back up current data */
     mData.assignCopy (aThat->mData);
-}
-
-HRESULT ParallelPort::loadSettings (CFGNODE aNode, ULONG aSlot)
-{
-    LogFlowThisFunc (("aMachine=%p\n", aNode));
-
-    AssertReturn (aNode, E_FAIL);
-
-    AutoCaller autoCaller (this);
-    AssertComRCReturnRC (autoCaller.rc());
-
-    AutoLock alock (this);
-
-    CFGNODE portNode = NULL;
-    CFGLDRGetChildNode (aNode, "Port", aSlot, &portNode);
-
-    /* slot number (required) */
-    /* slot unicity is guaranteed by XML Schema */
-    uint32_t uSlot = 0;
-    CFGLDRQueryUInt32 (portNode, "slot", &uSlot);
-    /* enabled (required) */
-    bool fEnabled = false;
-    CFGLDRQueryBool (portNode, "enabled", &fEnabled);
-    /* I/O base (required) */
-    uint32_t uIOBase;
-    CFGLDRQueryUInt32 (portNode, "IOBase", &uIOBase);
-    /* IRQ (required) */
-    uint32_t uIRQ;
-    CFGLDRQueryUInt32 (portNode, "IRQ", &uIRQ);
-    /* device path */
-    Bstr path;
-    CFGLDRQueryBSTR   (portNode, "path", path.asOutParam());
-
-    mData->mEnabled = fEnabled;
-    mData->mSlot    = uSlot;
-    mData->mIOBase  = uIOBase;
-    mData->mIRQ     = uIRQ;
-    mData->mPath    = path;
-
-    return S_OK;
-}
-
-/** 
- *  Saves the port settings to the given <Port> node.
- *
- *  Note that the given node is always empty so it is not necessary to delete
- *  old values.
- * 
- *  @param aNode Node to save the settings to.
- * 
- *  @return 
- */
-HRESULT ParallelPort::saveSettings (CFGNODE aNode)
-{
-    AssertReturn (aNode, E_FAIL);
-
-    AutoCaller autoCaller (this);
-    CheckComRCReturnRC (autoCaller.rc());
-
-    AutoReaderLock alock (this);
-
-    CFGNODE portNode = 0;
-    int vrc = CFGLDRAppendChildNode (aNode, "Port", &portNode);
-    ComAssertRCRet (vrc, E_FAIL);
-
-    CFGLDRSetUInt32   (portNode, "slot",    mData->mSlot);
-    CFGLDRSetBool     (portNode, "enabled", !!mData->mEnabled);
-    CFGLDRSetUInt32Ex (portNode, "IOBase",  mData->mIOBase, 16);
-    CFGLDRSetUInt32   (portNode, "IRQ",     mData->mIRQ);
-
-    /* 'path' is optional in XML */
-    if (!mData->mPath.isEmpty())
-        CFGLDRSetBSTR (portNode, "path", mData->mPath);
-
-    return S_OK;
 }
 

trunk/src/VBox/Main/SerialPortImpl.cpp

@@ -161 +161 @@
 
 /** 
- *  @note Locks this object for writing.
- */
-bool SerialPort::rollback()
-{
-    /* sanity */
-    AutoCaller autoCaller (this);
-    AssertComRCReturn (autoCaller.rc(), false);
-
-    AutoLock alock (this);
-
-    bool changed = false;
-
-    if (mData.isBackedUp())
-    {
-        /* we need to check all data to see whether anything will be changed
-         * after rollback */
-        changed = mData.hasActualChanges();
-        mData.rollback();
-    }
-
-    return changed;
-}
-
-/** 
- *  @note Locks this object for writing, together with the peer object (also
- *  for writing) if there is one.
- */
-void SerialPort::commit()
-{
-    /* sanity */
-    AutoCaller autoCaller (this);
-    AssertComRCReturnVoid (autoCaller.rc());
-
-    /* sanity too */
-    AutoCaller thatCaller (mPeer);
-    AssertComRCReturnVoid (thatCaller.rc());
-
-    /* lock both for writing since we modify both */
-    AutoMultiLock <2> alock (this->wlock(), AutoLock::maybeWlock (mPeer));
-
-    if (mData.isBackedUp())
-    {
-        mData.commit();
-        if (mPeer)
-        {
-            /* attach new data to the peer and reshare it */
-            mPeer->mData.attach (mData);
-        }
-    }
-}
-
-/** 
- *  @note Locks this object for writing, together with the peer object
- *  represented by @a aThat (locked for reading).
- */
-void SerialPort::copyFrom (SerialPort *aThat)
-{
-    AssertReturnVoid (aThat != NULL);
-
-    /* sanity */
-    AutoCaller autoCaller (this);
-    AssertComRCReturnVoid (autoCaller.rc());
-
-    /* sanity too */
-    AutoCaller thatCaller (mPeer);
-    AssertComRCReturnVoid (thatCaller.rc());
-
-    /* peer is not modified, lock it for reading */
-    AutoMultiLock <2> alock (this->wlock(), aThat->rlock());
-
-    /* this will back up current data */
-    mData.assignCopy (aThat->mData);
-}
-
-HRESULT SerialPort::loadSettings (CFGNODE aNode, ULONG aSlot)
-{
-    LogFlowThisFunc (("aMachine=%p\n", aNode));
-
-    AssertReturn (aNode, E_FAIL);
+ *  Loads settings from the given port node.
+ *  May be called once right after this object creation.
+ * 
+ *  @param aPortNode <Port> node.
+ * 
+ *  @note Locks this object for writing. 
+ */
+HRESULT SerialPort::loadSettings (const settings::Key &aPortNode)
+{
+    using namespace settings;
+
+    AssertReturn (!aPortNode.isNull(), E_FAIL);
 
     AutoCaller autoCaller (this);
@@ -246 +179 @@
     AutoLock alock (this);
 
-    HRESULT rc = S_OK;
-
-    CFGNODE portNode = NULL;
-    CFGLDRGetChildNode (aNode, "Port", aSlot, &portNode);
-
-    /* slot number (required) */
-    /* slot unicity is guaranteed by XML Schema */
-    uint32_t uSlot = 0;
-    CFGLDRQueryUInt32 (portNode, "slot", &uSlot);
+    /* Note: we assume that the default values for attributes of optional
+     * nodes are assigned in the Data::Data() constructor and don't do it
+     * here. It implies that this method may only be called after constructing
+     * a new BIOSSettings object while all its data fields are in the default
+     * values. Exceptions are fields whose creation time defaults don't match
+     * values that should be applied when these fields are not explicitly set
+     * in the settings file (for backwards compatibility reasons). This takes
+     * place when a setting of a newly created object must default to A while
+     * the same setting of an object loaded from the old settings file must
+     * default to B. */ 
+
     /* enabled (required) */
-    bool fEnabled = false;
-    CFGLDRQueryBool (portNode, "enabled", &fEnabled);
-    uint32_t uIOBase;
+    mData->mEnabled = aPortNode.value <bool> ("enabled");
     /* I/O base (required) */
-    CFGLDRQueryUInt32 (portNode, "IOBase", &uIOBase);
+    mData->mIOBase = aPortNode.value <ULONG> ("IOBase");
     /* IRQ (required) */
-    uint32_t uIRQ;
-    CFGLDRQueryUInt32 (portNode, "IRQ", &uIRQ);
+    mData->mIRQ = aPortNode.value <ULONG> ("IRQ");
     /* host mode (required) */
-    Bstr mode;
-    CFGLDRQueryBSTR (portNode, "hostMode", mode.asOutParam());
-    if (mode == L"HostPipe")
+    const char *mode = aPortNode.stringValue ("hostMode");
+    if (strcmp (mode, "HostPipe") == 0)
         mData->mHostMode = PortMode_HostPipePort;
-    else if (mode == L"HostDevice")
+    else if (strcmp (mode, "HostDevice") == 0)
         mData->mHostMode = PortMode_HostDevicePort;
+    else if (strcmp (mode, "Disconnected") == 0)
+        mData->mHostMode = PortMode_DisconnectedPort;
     else
-        mData->mHostMode = PortMode_DisconnectedPort;
-    /* pipe/device path */
-    Bstr path;
-    CFGLDRQueryBSTR (portNode, "path", path.asOutParam());
-    /* server mode */
-    bool fServer = true;
-    CFGLDRQueryBool (portNode, "server", &fServer);
-
-    mData->mEnabled  = fEnabled;
-    mData->mSlot     = uSlot;
-    mData->mIOBase   = uIOBase;
-    mData->mIRQ      = uIRQ;
-
-    rc = checkSetPath (path);
+        ComAssertMsgFailedRet (("Invalid port mode '%s'\n", mode), E_FAIL);
+
+    /* pipe/device path (optional, defaults to null) */
+    Bstr path = aPortNode.stringValue ("path");
+    HRESULT rc = checkSetPath (path);
     CheckComRCReturnRC (rc);
-
-    mData->mPath     = path;
-    mData->mServer   = fServer;
-
-    return rc;
-}
-
-/** 
- *  Saves the port settings to the given <Port> node.
- *
- *  Note that the given node is always empty so it is not necessary to delete
- *  old values.
+    mData->mPath = path;
+
+    /* server mode (optional, defaults to false) */
+    mData->mServer = aPortNode.value <bool> ("server");
+
+    return S_OK;
+}
+
+/**
+ *  Saves the port settings to the given port node.
+ *
+ *  Note that the given Port node is comletely empty on input.
+ *
+ *  @param aPortNode <Port> node.
  * 
- *  @param aNode Node to save the settings to.
- * 
- *  @return 
- */
-HRESULT SerialPort::saveSettings (CFGNODE aNode)
-{
-    AssertReturn (aNode, E_FAIL);
-
-    AutoCaller autoCaller (this);
-    CheckComRCReturnRC (autoCaller.rc());
-
-    AutoReaderLock alock (this);
-
-    CFGNODE portNode = 0;
-    int vrc = CFGLDRAppendChildNode (aNode, "Port", &portNode);
-    ComAssertRCRet (vrc, E_FAIL);
-
-    const char *mode;
+ *  @note Locks this object for reading.
+ */
+HRESULT SerialPort::saveSettings (settings::Key &aPortNode)
+{
+    using namespace settings;
+
+    AssertReturn (!aPortNode.isNull(), E_FAIL);
+
+    AutoCaller autoCaller (this);
+    AssertComRCReturnRC (autoCaller.rc());
+
+    AutoReaderLock alock (this);
+
+    aPortNode.setValue <bool> ("enabled", !!mData->mEnabled);
+    aPortNode.setValue <ULONG> ("IOBase", mData->mIOBase, 16);
+    aPortNode.setValue <ULONG> ("IRQ", mData->mIRQ);
+
+    const char *mode = NULL;
     switch (mData->mHostMode)
     {
-        default:
         case PortMode_DisconnectedPort:
             mode = "Disconnected";
@@ -330 +255 @@
             mode = "HostDevice";
             break;
-    }
-    CFGLDRSetUInt32   (portNode, "slot",     mData->mSlot);
-    CFGLDRSetBool     (portNode, "enabled",  !!mData->mEnabled);
-    CFGLDRSetUInt32Ex (portNode, "IOBase",   mData->mIOBase, 16);
-    CFGLDRSetUInt32   (portNode, "IRQ",      mData->mIRQ);
-    CFGLDRSetString   (portNode, "hostMode", mode);
-
+        default:
+            ComAssertMsgFailedRet (("Invalid serial port mode: %d\n",
+                                    mData->mHostMode),
+                                   E_FAIL);
+    }
+    aPortNode.setStringValue ("hostMode", mode);
+    
     /* Always save non-null mPath and mServer to preserve the user values for
      * later use. Note that 'server' is false by default in XML so we don't
      * save it when it's false. */
     if (!mData->mPath.isEmpty())
-        CFGLDRSetBSTR (portNode, "path", mData->mPath);
+        aPortNode.setValue <Bstr> ("path", mData->mPath);
     if (mData->mServer)
-        CFGLDRSetBool (portNode, "server", !!mData->mServer);
-
-    return S_OK;
+        aPortNode.setValue <bool> ("server", !!mData->mServer);
+
+    return S_OK;
+}
+
+/** 
+ *  @note Locks this object for writing.
+ */
+bool SerialPort::rollback()
+{
+    /* sanity */
+    AutoCaller autoCaller (this);
+    AssertComRCReturn (autoCaller.rc(), false);
+
+    AutoLock alock (this);
+
+    bool changed = false;
+
+    if (mData.isBackedUp())
+    {
+        /* we need to check all data to see whether anything will be changed
+         * after rollback */
+        changed = mData.hasActualChanges();
+        mData.rollback();
+    }
+
+    return changed;
+}
+
+/** 
+ *  @note Locks this object for writing, together with the peer object (also
+ *  for writing) if there is one.
+ */
+void SerialPort::commit()
+{
+    /* sanity */
+    AutoCaller autoCaller (this);
+    AssertComRCReturnVoid (autoCaller.rc());
+
+    /* sanity too */
+    AutoCaller thatCaller (mPeer);
+    AssertComRCReturnVoid (thatCaller.rc());
+
+    /* lock both for writing since we modify both */
+    AutoMultiLock <2> alock (this->wlock(), AutoLock::maybeWlock (mPeer));
+
+    if (mData.isBackedUp())
+    {
+        mData.commit();
+        if (mPeer)
+        {
+            /* attach new data to the peer and reshare it */
+            mPeer->mData.attach (mData);
+        }
+    }
+}
+
+/** 
+ *  @note Locks this object for writing, together with the peer object
+ *  represented by @a aThat (locked for reading).
+ */
+void SerialPort::copyFrom (SerialPort *aThat)
+{
+    AssertReturnVoid (aThat != NULL);
+
+    /* sanity */
+    AutoCaller autoCaller (this);
+    AssertComRCReturnVoid (autoCaller.rc());
+
+    /* sanity too */
+    AutoCaller thatCaller (mPeer);
+    AssertComRCReturnVoid (thatCaller.rc());
+
+    /* peer is not modified, lock it for reading */
+    AutoMultiLock <2> alock (this->wlock(), aThat->rlock());
+
+    /* this will back up current data */
+    mData.assignCopy (aThat->mData);
 }
 

trunk/src/VBox/Main/SnapshotImpl.cpp

@@ -32 +32 @@
 Snapshot::Data::Data()
 {
-    mTimeStamp = 0;
+    RTTimeSpecSetMilli (&mTimeStamp, 0);
 };
 
@@ -62 +62 @@
  */
 HRESULT Snapshot::init (const Guid &aId, INPTR BSTR aName, INPTR BSTR aDescription,
-                        LONG64 aTimeStamp, SnapshotMachine *aMachine,
+                        RTTIMESPEC aTimeStamp, SnapshotMachine *aMachine,
                         Snapshot *aParent)
 {
@@ -249 +249 @@
     CHECK_READY();
 
-    *aTimeStamp = mData.mTimeStamp;
+    *aTimeStamp = RTTimeSpecGetMilli (&mData.mTimeStamp);
     return S_OK;
 }

trunk/src/VBox/Main/SystemPropertiesImpl.cpp

@@ -378 +378 @@
 /////////////////////////////////////////////////////////////////////////////
 
-HRESULT SystemProperties::loadSettings (CFGNODE aGlobal)
-{
+HRESULT SystemProperties::loadSettings (const settings::Key &aGlobal)
+{
+    using namespace settings;
+
     AutoLock lock (this);
     CHECK_READY();
 
-    ComAssertRet (aGlobal, E_FAIL);
-
-    CFGNODE properties = NULL;
-    CFGLDRGetChildNode (aGlobal, "SystemProperties", 0, &properties);
-    ComAssertRet (properties, E_FAIL);
-
-    HRESULT rc = E_FAIL;
-
-    do
-    {
-        Bstr bstr;
-
-        CFGLDRQueryBSTR (properties, "defaultVDIFolder",
-                         bstr.asOutParam());
-        rc = setDefaultVDIFolder (bstr);
-        if (FAILED (rc))
-            break;
-
-        CFGLDRQueryBSTR (properties, "defaultMachineFolder",
-                         bstr.asOutParam());
-        rc = setDefaultMachineFolder (bstr);
-        if (FAILED (rc))
-            break;
-
-        CFGLDRQueryBSTR (properties, "remoteDisplayAuthLibrary",
-                         bstr.asOutParam());
-        rc = setRemoteDisplayAuthLibrary (bstr);
-        if (FAILED (rc))
-            break;
-
-        CFGLDRQueryBSTR (properties, "webServiceAuthLibrary",
-                         bstr.asOutParam());
-        rc = setWebServiceAuthLibrary (bstr);
-        if (FAILED (rc))
-            break;
-
-        CFGLDRQueryBool (properties, "HWVirtExEnabled", (bool*)&mHWVirtExEnabled);
-
-        uint32_t u32Count = 3;
-        CFGLDRQueryUInt32 (properties, "LogHistoryCount", &u32Count);
-        mLogHistoryCount = u32Count;
-    }
-    while (0);
-
-    CFGLDRReleaseNode (properties);
-
-    return rc;
-}
-
-HRESULT SystemProperties::saveSettings (CFGNODE aGlobal)
-{
+    AssertReturn (!aGlobal.isNull(), E_FAIL);
+
+    HRESULT rc = S_OK;
+
+    Key properties = aGlobal.key ("SystemProperties");
+
+    Bstr bstr;
+
+    bstr = properties.stringValue ("defaultVDIFolder");
+    rc = setDefaultVDIFolder (bstr);
+    CheckComRCReturnRC (rc);
+
+    bstr = properties.stringValue ("defaultMachineFolder");
+    rc = setDefaultMachineFolder (bstr);
+    CheckComRCReturnRC (rc);
+
+    bstr = properties.stringValue ("remoteDisplayAuthLibrary");
+    rc = setRemoteDisplayAuthLibrary (bstr);
+    CheckComRCReturnRC (rc);
+
+    bstr = properties.stringValue ("webServiceAuthLibrary");
+    rc = setWebServiceAuthLibrary (bstr);
+    CheckComRCReturnRC (rc);
+
+    /* Note: not <BOOL> because Win32 defines BOOL as int */
+    mHWVirtExEnabled = properties.value <bool> ("HWVirtExEnabled");
+
+    mLogHistoryCount = properties.value <ULONG> ("LogHistoryCount");
+
+    return S_OK;
+}
+
+HRESULT SystemProperties::saveSettings (settings::Key &aGlobal)
+{
+    using namespace settings;
+
     AutoLock lock (this);
     CHECK_READY();
 
-    ComAssertRet (aGlobal, E_FAIL);
-
-    // first, delete the entry
-    CFGNODE properties = NULL;
-    int vrc = CFGLDRGetChildNode (aGlobal, "SystemProperties", 0, &properties);
-    if (VBOX_SUCCESS (vrc))
-    {
-        vrc = CFGLDRDeleteNode (properties);
-        ComAssertRCRet (vrc, E_FAIL);
-    }
-    // then, recreate it
-    vrc = CFGLDRCreateChildNode (aGlobal, "SystemProperties", &properties);
-    ComAssertRCRet (vrc, E_FAIL);
+    ComAssertRet (!aGlobal.isNull(), E_FAIL);
+
+    /* first, delete the entry */
+    Key properties = aGlobal.findKey ("SystemProperties");
+    if (!properties.isNull())
+        properties.zap();
+    /* then, recreate it */
+    properties = aGlobal.createKey ("SystemProperties");
 
     if (mDefaultVDIFolder)
-        CFGLDRSetBSTR (properties, "defaultVDIFolder",
-                       mDefaultVDIFolder);
+        properties.setValue <Bstr> ("defaultVDIFolder", mDefaultVDIFolder);
 
     if (mDefaultMachineFolder)
-        CFGLDRSetBSTR (properties, "defaultMachineFolder",
-                       mDefaultMachineFolder);
+        properties.setValue <Bstr> ("defaultMachineFolder", mDefaultMachineFolder);
 
     if (mRemoteDisplayAuthLibrary)
-        CFGLDRSetBSTR (properties, "remoteDisplayAuthLibrary",
-                       mRemoteDisplayAuthLibrary);
+        properties.setValue <Bstr> ("remoteDisplayAuthLibrary", mRemoteDisplayAuthLibrary);
 
     if (mWebServiceAuthLibrary)
-        CFGLDRSetBSTR (properties, "webServiceAuthLibrary",
-                       mWebServiceAuthLibrary);
-
-    CFGLDRSetBool (properties, "HWVirtExEnabled", !!mHWVirtExEnabled);
-
-    CFGLDRSetUInt32 (properties, "LogHistoryCount", mLogHistoryCount);
+        properties.setValue <Bstr> ("webServiceAuthLibrary", mWebServiceAuthLibrary);
+
+    properties.setValue <bool> ("HWVirtExEnabled", !!mHWVirtExEnabled);
+
+    properties.setValue <ULONG> ("LogHistoryCount", mLogHistoryCount);
 
     return S_OK;

trunk/src/VBox/Main/USBControllerImpl.cpp

@@ -481 +481 @@
 /////////////////////////////////////////////////////////////////////////////
 
-/**
- *  Loads settings from the configuration node.
- *
- *  @note Locks objects for writing!
+/** 
+ *  Loads settings from the given machine node.
+ *  May be called once right after this object creation.
+ * 
+ *  @param aMachineNode <Machine> node.
+ * 
+ *  @note Locks this object for writing. 
  */
-HRESULT USBController::loadSettings (CFGNODE aMachine)
-{
-    AssertReturn (aMachine, E_FAIL);
+HRESULT USBController::loadSettings (const settings::Key &aMachineNode)
+{
+    using namespace settings;
+
+    AssertReturn (!aMachineNode.isNull(), E_FAIL);
 
     AutoCaller autoCaller (this);
@@ -495 +500 @@
     AutoLock alock (this);
 
-    CFGNODE controller = NULL;
-    CFGLDRGetChildNode (aMachine, "USBController", 0, &controller);
-    Assert (controller);
-
-    /* enabled */
-    bool enabled;
-    CFGLDRQueryBool (controller, "enabled", &enabled);
-    mData->mEnabled = enabled;
-
-    /* enabledEhci */
-    CFGLDRQueryBool (controller, "enabledEhci", &enabled);
-    mData->mEnabledEhci = enabled;
+    /* Note: we assume that the default values for attributes of optional
+     * nodes are assigned in the Data::Data() constructor and don't do it
+     * here. It implies that this method may only be called after constructing
+     * a new BIOSSettings object while all its data fields are in the default
+     * values. Exceptions are fields whose creation time defaults don't match
+     * values that should be applied when these fields are not explicitly set
+     * in the settings file (for backwards compatibility reasons). This takes
+     * place when a setting of a newly created object must default to A while
+     * the same setting of an object loaded from the old settings file must
+     * default to B. */ 
+
+    /* USB Controller node (required) */
+    Key controller = aMachineNode.key ("USBController");
+
+    /* enabled (required) */
+    mData->mEnabled = controller.value <bool> ("enabled");
+
+    /* enabledEhci (optiona, defaults to false) */
+    mData->mEnabledEhci = controller.value <bool> ("enabledEhci");
 
     HRESULT rc = S_OK;
 
-    unsigned filterCount = 0;
-    CFGLDRCountChildren (controller, "DeviceFilter", &filterCount);
-    for (unsigned i = 0; i < filterCount && SUCCEEDED (rc); i++)
-    {
-        CFGNODE filter = NULL;
-        CFGLDRGetChildNode (controller, "DeviceFilter", i, &filter);
-        Assert (filter);
-
-        Bstr name;
-        CFGLDRQueryBSTR (filter, "name", name.asOutParam());
-        bool active;
-        CFGLDRQueryBool (filter, "active", &active);
-
-        Bstr vendorId;
-        CFGLDRQueryBSTR (filter, "vendorid", vendorId.asOutParam());
-        Bstr productId;
-        CFGLDRQueryBSTR (filter, "productid", productId.asOutParam());
-        Bstr revision;
-        CFGLDRQueryBSTR (filter, "revision", revision.asOutParam());
-        Bstr manufacturer;
-        CFGLDRQueryBSTR (filter, "manufacturer", manufacturer.asOutParam());
-        Bstr product;
-        CFGLDRQueryBSTR (filter, "product", product.asOutParam());
-        Bstr serialNumber;
-        CFGLDRQueryBSTR (filter, "serialnumber", serialNumber.asOutParam());
-        Bstr port;
-        CFGLDRQueryBSTR (filter, "port", port.asOutParam());
-        Bstr remote;
-        CFGLDRQueryBSTR (filter, "remote", remote.asOutParam());
-        uint32_t maskedIfs;
-        if (RT_FAILURE(CFGLDRQueryUInt32 (filter, "maskedInterfaces", &maskedIfs)))
-            maskedIfs = 0;
+    Key::List children = controller.keys ("DeviceFilter");
+    for (Key::List::const_iterator it = children.begin();
+         it != children.end(); ++ it)
+    {
+        /* required */
+        Bstr name = (*it).stringValue ("name");
+        bool active = (*it).value <bool> ("active");
+
+        /* optional */
+        Bstr vendorId = (*it).stringValue ("vendorid");
+        Bstr productId = (*it).stringValue ("productid");
+        Bstr revision = (*it).stringValue ("revision");
+        Bstr manufacturer = (*it).stringValue ("manufacturer");
+        Bstr product = (*it).stringValue ("product");
+        Bstr serialNumber = (*it).stringValue ("serialnumber");
+        Bstr port = (*it).stringValue ("port");
+        Bstr remote = (*it).stringValue ("remote");
+        ULONG maskedIfs = (*it).value <ULONG> ("maskedInterfaces");
 
         ComObjPtr <USBDeviceFilter> filterObj;
@@ -550 +548 @@
                               port, remote, maskedIfs);
         /* error info is set by init() when appropriate */
-        if (SUCCEEDED (rc))
-        {
-            mDeviceFilters->push_back (filterObj);
-            filterObj->mInList = true;
-        }
-
-        CFGLDRReleaseNode (filter);
-    }
-
-    CFGLDRReleaseNode (controller);
-
-    return rc;
-}
-
-/**
- *  Saves settings to the configuration node.
- *
- *  @note Locks objects for reading!
+        CheckComRCReturnRC (rc);
+
+        mDeviceFilters->push_back (filterObj);
+        filterObj->mInList = true;
+    }
+
+    return S_OK;
+}
+
+/** 
+ *  Saves settings to the given machine node.
+ * 
+ *  @param aMachineNode <Machine> node.
+ * 
+ *  @note Locks this object for reading.
  */
-HRESULT USBController::saveSettings (CFGNODE aMachine)
-{
-    AssertReturn (aMachine, E_FAIL);
+HRESULT USBController::saveSettings (settings::Key &aMachineNode)
+{
+    using namespace settings;
+
+    AssertReturn (!aMachineNode.isNull(), E_FAIL);
 
     AutoCaller autoCaller (this);
@@ -579 +576 @@
 
     /* first, delete the entry */
-    CFGNODE controller = NULL;
-    int vrc = CFGLDRGetChildNode (aMachine, "USBController", 0, &controller);
-    if (VBOX_SUCCESS (vrc))
-    {
-        vrc = CFGLDRDeleteNode (controller);
-        ComAssertRCRet (vrc, E_FAIL);
-    }
+    Key controller = aMachineNode.findKey ("USBController");
+    if (!controller.isNull())
+        controller.zap();
     /* then, recreate it */
-    vrc = CFGLDRCreateChildNode (aMachine, "USBController", &controller);
-    ComAssertRCRet (vrc, E_FAIL);
+    controller = aMachineNode.createKey ("USBController");
 
     /* enabled */
-    CFGLDRSetBool (controller, "enabled", !!mData->mEnabled);
+    controller.setValue <bool> ("enabled", !!mData->mEnabled);
 
     /* enabledEhci */
-    CFGLDRSetBool (controller, "enabledEhci", !!mData->mEnabledEhci);
+    controller.setValue <bool> ("enabledEhci", !!mData->mEnabledEhci);
 
     DeviceFilterList::const_iterator it = mDeviceFilters->begin();
@@ -602 +594 @@
         const USBDeviceFilter::Data &data = (*it)->data();
 
-        CFGNODE filter = NULL;
-        CFGLDRAppendChildNode (controller, "DeviceFilter",  &filter);
-
-        CFGLDRSetBSTR (filter, "name", data.mName);
-        CFGLDRSetBool (filter, "active", !!data.mActive);
+        Key filter = controller.appendKey ("DeviceFilter");
+
+        filter.setValue <Bstr> ("name", data.mName);
+        filter.setValue <bool> ("active", !!data.mActive);
 
         /* all are optional */
 #ifndef VBOX_WITH_USBFILTER
+
         if (data.mVendorId.string())
-            CFGLDRSetBSTR (filter, "vendorid", data.mVendorId.string());
+            filter.setValue <Bstr> ("vendorid", data.mVendorId.string());
         if (data.mProductId.string())
-            CFGLDRSetBSTR (filter, "productid", data.mProductId.string());
+            filter.setValue <Bstr> ("productid", data.mProductId.string());
         if (data.mRevision.string())
-            CFGLDRSetBSTR (filter, "revision", data.mRevision.string());
+            filter.setValue <Bstr> ("revision", data.mRevision.string());
         if (data.mManufacturer.string())
-            CFGLDRSetBSTR (filter, "manufacturer", data.mManufacturer.string());
+            filter.setValue <Bstr> ("manufacturer", data.mManufacturer.string());
         if (data.mProduct.string())
-            CFGLDRSetBSTR (filter, "product", data.mProduct.string());
+            filter.setValue <Bstr> ("product", data.mProduct.string());
         if (data.mSerialNumber.string())
-            CFGLDRSetBSTR (filter, "serialnumber", data.mSerialNumber.string());
+            filter.setValue <Bstr> ("serialnumber", data.mSerialNumber.string());
         if (data.mPort.string())
-            CFGLDRSetBSTR (filter, "port", data.mPort.string());
+            filter.setValue <Bstr> ("port", data.mPort.string());
         if (data.mRemote.string())
-            CFGLDRSetBSTR (filter, "remote", data.mRemote.string());
+            filter.setValue <Bstr> ("remote", data.mRemote.string());
 
 #else  /* VBOX_WITH_USBFILTER */
+
         Bstr str;
         (*it)->COMGETTER (VendorId) (str.asOutParam());
         if (!str.isNull())
-            CFGLDRSetBSTR (filter, "vendorid", str);
+            filter.setValue <Bstr> ("vendorid", str);
 
         (*it)->COMGETTER (ProductId) (str.asOutParam());
         if (!str.isNull())
-            CFGLDRSetBSTR (filter, "productid", str);
+            filter.setValue <Bstr> ("productid", str);
 
         (*it)->COMGETTER (Revision) (str.asOutParam());
         if (!str.isNull())
-            CFGLDRSetBSTR (filter, "revision", str);
+            filter.setValue <Bstr> ("revision", str);
 
         (*it)->COMGETTER (Manufacturer) (str.asOutParam());
         if (!str.isNull())
-            CFGLDRSetBSTR (filter, "manufacturer", str);
+            filter.setValue <Bstr> ("manufacturer", str);
 
         (*it)->COMGETTER (Product) (str.asOutParam());
         if (!str.isNull())
-            CFGLDRSetBSTR (filter, "product", str);
+            filter.setValue <Bstr> ("product", str);
 
         (*it)->COMGETTER (SerialNumber) (str.asOutParam());
         if (!str.isNull())
-            CFGLDRSetBSTR (filter, "serialnumber", str);
+            filter.setValue <Bstr> ("serialnumber", str);
 
         (*it)->COMGETTER (Port) (str.asOutParam());
         if (!str.isNull())
-            CFGLDRSetBSTR (filter, "port", str);
+            filter.setValue <Bstr> ("port", str);
 
         if (data.mRemote.string())
-            CFGLDRSetBSTR (filter, "remote", data.mRemote.string());
+            filter.setValue <Bstr> ("remote", data.mRemote.string());
+
 #endif /* VBOX_WITH_USBFILTER */
 
         if (data.mMaskedIfs)
-            CFGLDRSetUInt32 (filter, "maskedInterfaces", data.mMaskedIfs);
-
-        CFGLDRReleaseNode (filter);
+            filter.setValue <ULONG> ("maskedInterfaces", data.mMaskedIfs);
 
         ++ it;
     }
-
-    CFGLDRReleaseNode (controller);
 
     return S_OK;

trunk/src/VBox/Main/VBoxDll.cpp

@@ -21 +21 @@
 *******************************************************************************/
 #include <iprt/assert.h>
-#undef CFGLDR_HAVE_COM
-#include <VBox/cfgldr.h>
 
 void __reference_stuff(void);

trunk/src/VBox/Main/VirtualBoxBase.cpp

@@ +1 @@
+/* $Id$ */
+
 /** @file
  *
@@ -930 +932 @@
 }
 
+#if defined VBOX_MAIN_SETTINGS_ADDONS
+
+// Settings API additions
+////////////////////////////////////////////////////////////////////////////////
+
+namespace settings
+{
+
+template<> stdx::char_auto_ptr
+ToString <com::Bstr> (const com::Bstr &aValue, unsigned int aExtra)
+{
+    stdx::char_auto_ptr result;
+
+    if (aValue.raw() == NULL)
+        throw ENoValue();
+
+    /* The only way to cause RTUtf16ToUtf8Ex return a number of bytes needed
+     * w/o allocating the result buffer itself is to provide that both cch
+     * and *ppsz are not NULL. */
+    char dummy [1];
+    char *dummy2 = dummy;
+    size_t strLen = 1;
+
+    int vrc = RTUtf16ToUtf8Ex (aValue.raw(), RTSTR_MAX,
+                               &dummy2, strLen, &strLen);
+    if (RT_SUCCESS (vrc))
+    {
+        /* the string only contains '\0' :) */
+        result.reset (new char [1]);
+        result.get() [0] = '\0';
+        return result;
+    }
+
+    if (vrc == VERR_BUFFER_OVERFLOW)
+    {
+        result.reset (new char [strLen + 1]);
+        char *buf = result.get();
+        vrc = RTUtf16ToUtf8Ex (aValue.raw(), RTSTR_MAX, &buf, strLen + 1, NULL);
+    }
+
+    if (RT_FAILURE (vrc))
+        throw LogicError (RT_SRC_POS);
+
+    return result;
+}
+
+template<> com::Guid FromString <com::Guid> (const char *aValue)
+{
+    if (aValue == NULL)
+        throw ENoValue();
+
+    /* For settings, the format is always {XXX...XXX} */
+    char buf [RTUUID_STR_LENGTH];
+    if (aValue == NULL || *aValue != '{' ||
+        strlen (aValue) != RTUUID_STR_LENGTH + 1 ||
+        aValue [RTUUID_STR_LENGTH] != '}')
+        throw ENoConversion (FmtStr ("'%s' is not Guid", aValue));
+
+    /* strip { and } */
+    memcpy (buf, aValue + 1, RTUUID_STR_LENGTH - 1);
+    buf [RTUUID_STR_LENGTH - 1] = '\0';
+    /* we don't use Guid (const char *) because we want to throw
+     * ENoConversion on format error */
+    RTUUID uuid;
+    int vrc = RTUuidFromStr (&uuid, buf);
+    if (RT_FAILURE (vrc))
+        throw ENoConversion (FmtStr ("'%s' is not Guid (%Vrc)", aValue, vrc));
+        
+    return com::Guid (uuid);
+}
+
+template<> stdx::char_auto_ptr
+ToString <com::Guid> (const com::Guid &aValue, unsigned int aExtra)
+{
+    /* For settings, the format is always {XXX...XXX} */
+    stdx::char_auto_ptr result (new char [RTUUID_STR_LENGTH + 2]);
+
+    int vrc = RTUuidToStr (aValue.raw(), result.get() + 1, RTUUID_STR_LENGTH);
+    if (RT_FAILURE (vrc))
+        throw LogicError (RT_SRC_POS);
+
+    result.get() [0] = '{';
+    result.get() [RTUUID_STR_LENGTH] = '}';
+    result.get() [RTUUID_STR_LENGTH + 1] = '\0';
+
+    return result;
+}
+
+} /* namespace settings */
+
+#endif /* VBOX_MAIN_SETTINGS_ADDONS */

trunk/src/VBox/Main/VirtualBoxImpl.cpp

@@ -26 +26 @@
 #include "USBControllerImpl.h"
 #include "SystemPropertiesImpl.h"
+#include "GuestOSTypeImpl.h"
+
+#include "VirtualBoxXMLUtil.h"
+
 #include "Logging.h"
-
-#include "GuestOSTypeImpl.h"
 
 #ifdef RT_OS_WINDOWS
@@ -59 +61 @@
 #include <set>
 #include <memory> // for auto_ptr
+
+#include <typeinfo>
 
 // defines
@@ -187 +191 @@
     }
 
-    /* initialize our Xerces XML subsystem */
     if (SUCCEEDED (rc))
     {
-        int vrc = CFGLDRInitialize();
-        if (VBOX_FAILURE (vrc))
-            rc = setError (E_FAIL, tr ("Could not initialize the XML parser (%Vrc)"),
-                                   vrc);
-    }
-
-    if (SUCCEEDED (rc))
-    {
-        CFGHANDLE configLoader = NULL;
-        char *loaderError = NULL;
-
-        /* load the config file */
-        int vrc = CFGLDRLoad (&configLoader, vboxConfigFile, mData.mCfgFile.mHandle,
-                              XmlSchemaNS, true, cfgLdrEntityResolver,
-                              &loaderError);
-        if (VBOX_SUCCESS (vrc))
-        {
-            CFGNODE global = NULL;
-            CFGLDRGetNode (configLoader, "VirtualBox/Global", 0, &global);
-            Assert (global);
-
-            do
-            {
-                /* create the host object early, machines will need it */
-                unconst (mData.mHost).createObject();
-                rc = mData.mHost->init (this);
-                ComAssertComRCBreak (rc, rc = rc);
-
-                unconst (mData.mSystemProperties).createObject();
-                rc = mData.mSystemProperties->init (this);
-                ComAssertComRCBreak (rc, rc = rc);
-
-                rc = loadDisks (global);
-                CheckComRCBreakRC ((rc));
-
-                /* guest OS type objects, needed by the machines */
-                rc = registerGuestOSTypes();
-                ComAssertComRCBreak (rc, rc = rc);
-
-                /* machines */
-                rc = loadMachines (global);
-                CheckComRCBreakRC ((rc));
-
-                /* host data (USB filters) */
-                rc = mData.mHost->loadSettings (global);
-                CheckComRCBreakRC ((rc));
-
-                rc = mData.mSystemProperties->loadSettings (global);
-                CheckComRCBreakRC ((rc));
-
-                /* check hard disk consistency */
+        try
+        {
+            using namespace settings;
+
+            File file (File::ReadWrite, mData.mCfgFile.mHandle, vboxConfigFile);
+            XmlTreeBackend tree;
+
+            rc = VirtualBox::loadSettingsTree_FirstTime (tree, file);
+            CheckComRCThrowRC (rc);
+
+            Key global = tree.rootKey().key ("Global");
+
+            /* create the host object early, machines will need it */
+            unconst (mData.mHost).createObject();
+            rc = mData.mHost->init (this);
+            ComAssertComRCThrowRC (rc);
+
+            rc = mData.mHost->loadSettings (global);
+            CheckComRCThrowRC (rc);
+
+            /* create the system properties object */
+            unconst (mData.mSystemProperties).createObject();
+            rc = mData.mSystemProperties->init (this);
+            ComAssertComRCThrowRC (rc);
+
+            rc = mData.mSystemProperties->loadSettings (global);
+            CheckComRCThrowRC (rc);
+
+            /* guest OS type objects, needed by machines */
+            rc = registerGuestOSTypes();
+            ComAssertComRCThrowRC (rc);
+
+            /* hard disks, needed by machines */
+            rc = loadDisks (global);
+            CheckComRCThrowRC (rc);
+
+            /* machines */
+            rc = loadMachines (global);
+            CheckComRCThrowRC (rc);
+
+            /* check hard disk consistency */
 /// @todo (r=dmik) add IVirtualBox::cleanupHardDisks() instead or similar
-//                for (HardDiskList::const_iterator it = mData.mHardDisks.begin();
-//                     it != mData.mHardDisks.end() && SUCCEEDED (rc);
-//                     ++ it)
-//                {
-//                    rc = (*it)->checkConsistency();
-//                }
-//                CheckComRCBreakRC ((rc));
-            }
-            while (0);
+//            for (HardDiskList::const_iterator it = mData.mHardDisks.begin();
+//                 it != mData.mHardDisks.end() && SUCCEEDED (rc);
+//                 ++ it)
+//            {
+//                rc = (*it)->checkConsistency();
+//            }
+//            CheckComRCBreakRC ((rc));
 
             /// @todo (dmik) if successful, check for orphan (unused) diffs
-            //  that might be left because of the server crash, and remove them.
-
-            CFGLDRReleaseNode (global);
-            CFGLDRFree(configLoader);
-        }
-        else
-        {
-            rc = setError (E_FAIL,
-                tr ("Could not load the settings file '%ls' (%Vrc)%s%s"),
-                mData.mCfgFile.mName.raw(), vrc,
-                loaderError ? ".\n" : "", loaderError ? loaderError : "");
-        }
-
-        if (loaderError)
-            RTMemTmpFree (loaderError);
+            //  that might be left because of the server crash, and remove
+            //  Hmm, is it the same remark as above?..
+        }
+        catch (HRESULT err)
+        {
+            /* we assume that error info is set by the thrower */
+            rc = err;
+        }
+        catch (...)
+        {
+            rc = VirtualBox::handleUnexpectedExceptions (RT_SRC_POS);
+        }
     }
 
@@ -436 +424 @@
 #endif
 
-    /* uninitialize the Xerces XML subsystem */
-    CFGLDRShutdown();
-
     LogFlowThisFuncLeave();
     LogFlow (("===========================================================\n"));
@@ -914 +899 @@
 
     /* save the global registry */
-    rc = saveConfig();
+    rc = saveSettings();
 
     /* return the unregistered machine to the caller */
@@ -1365 +1350 @@
 
         /* save the global config file */
-        rc = saveConfig();
+        rc = saveSettings();
 
         if (SUCCEEDED (rc))
@@ -1534 +1519 @@
 
         /* save the global config file */
-        rc = saveConfig();
+        rc = saveSettings();
         if (SUCCEEDED (rc))
         {
@@ -1604 +1589 @@
 }
 
-/** @note Locks this object for reading. */
+/**
+ *  @note Locks this object for reading.
+ */
 STDMETHODIMP VirtualBox::
 GetNextExtraDataKey (INPTR BSTR aKey, BSTR *aNextKey, BSTR *aNextValue)
@@ -1616 +1603 @@
     /* start with nothing found */
     *aNextKey = NULL;
+    if (aNextValue)
+        *aNextValue = NULL;
 
     HRESULT rc = S_OK;
 
-    /* serialize file access */
+    /* serialize config file access */
     AutoReaderLock alock (this);
 
-    CFGHANDLE configLoader;
-
-    /* load the config file */
-    int vrc = CFGLDRLoad (&configLoader, Utf8Str (mData.mCfgFile.mName),
-                          mData.mCfgFile.mHandle,
-                          XmlSchemaNS, true, cfgLdrEntityResolver, NULL);
-    ComAssertRCRet (vrc, E_FAIL);
-
-    CFGNODE extraDataNode;
-
-    /* navigate to the right position */
-    if (VBOX_SUCCESS (CFGLDRGetNode (configLoader,
-                                     "VirtualBox/Global/ExtraData", 0,
-                                     &extraDataNode)))
-    {
-        /* check if it exists */
-        bool found = false;
-        unsigned count;
-        CFGNODE extraDataItemNode;
-        CFGLDRCountChildren (extraDataNode, "ExtraDataItem", &count);
-        for (unsigned i = 0; (i < count) && (found == false); i++)
-        {
-            Bstr name;
-            CFGLDRGetChildNode (extraDataNode, "ExtraDataItem", i, &extraDataItemNode);
-            CFGLDRQueryBSTR (extraDataItemNode, "name", name.asOutParam());
-
-            /* if we're supposed to return the first one */
-            if (aKey == NULL)
+    try
+    {
+        using namespace settings;
+
+        /* load the config file */
+        File file (File::ReadWrite, mData.mCfgFile.mHandle,
+                   Utf8Str (mData.mCfgFile.mName));
+        XmlTreeBackend tree;
+
+        rc = VirtualBox::loadSettingsTree_Again (tree, file);
+        CheckComRCReturnRC (rc);
+
+        Key globalNode = tree.rootKey().key ("Global");
+        Key extraDataNode = tree.rootKey().findKey ("ExtraData");
+
+        if (!extraDataNode.isNull())
+        {
+            Key::List items = extraDataNode.keys ("ExtraDataItem");
+            if (items.size())
             {
-                name.cloneTo (aNextKey);
-                if (aNextValue)
-                    CFGLDRQueryBSTR (extraDataItemNode, "value", aNextValue);
-                found = true;
-            }
-            /* did we find the key we're looking for? */
-            else if (name == aKey)
-            {
-                found = true;
-                /* is there another item? */
-                if (i + 1 < count)
+                for (Key::List::const_iterator it = items.begin();
+                     it != items.end(); ++ it)
                 {
-                    CFGLDRGetChildNode (extraDataNode, "ExtraDataItem", i + 1,
-                                        &extraDataItemNode);
-                    CFGLDRQueryBSTR (extraDataItemNode, "name", name.asOutParam());
-                    name.cloneTo (aNextKey);
-                    if (aNextValue)
-                        CFGLDRQueryBSTR (extraDataItemNode, "value", aNextValue);
-                    found = true;
-                }
-                else
-                {
-                    /* it's the last one */
-                    *aNextKey = NULL;
+                    Bstr key = (*it).stringValue ("name");
+
+                    /* if we're supposed to return the first one */
+                    if (aKey == NULL)
+                    {
+                        key.cloneTo (aNextKey);
+                        if (aNextValue)
+                        {
+                            Bstr val = (*it).stringValue ("value");
+                            val.cloneTo (aNextValue);
+                        }
+                        return S_OK;
+                    }
+
+                    /* did we find the key we're looking for? */
+                    if (key == aKey)
+                    {
+                        ++ it;
+                        /* is there another item? */
+                        if (it != items.end())
+                        {
+                            Bstr key = (*it).stringValue ("name");
+                            key.cloneTo (aNextKey);
+                            if (aNextValue)
+                            {
+                                Bstr val = (*it).stringValue ("value");
+                                val.cloneTo (aNextValue);
+                            }
+                        }
+                        /* else it's the last one, arguments are already NULL */
+                        return S_OK;
+                    }
                 }
             }
-            CFGLDRReleaseNode (extraDataItemNode);
-        }
-
-        /* if we haven't found the key, it's an error */
-        if (!found)
-            rc = setError (E_FAIL,
-                tr ("Could not find extra data key '%ls'"), aKey);
-
-        CFGLDRReleaseNode (extraDataNode);
-    }
-
-    CFGLDRFree (configLoader);
-
-    return rc;
-}
-
-/** @note Locks this object for reading. */
+        }
+
+        /* Here we are when a) there are no items at all or b) there are items
+         * but none of them equals to the requested non-NULL key. b) is an
+         * error as well as a) if the key is non-NULL. When the key is NULL
+         * (which is the case only when there are no items), we just fall
+         * through to return NULLs and S_OK. */
+
+        if (aKey != NULL)
+            return setError (E_FAIL,
+                tr ("Could not find the extra data key '%ls'"), aKey);
+    }
+    catch (...)
+    {
+        rc = VirtualBox::handleUnexpectedExceptions (RT_SRC_POS);
+    }
+
+    return rc;
+}
+
+/**
+ *  @note Locks this object for reading.
+ */
 STDMETHODIMP VirtualBox::GetExtraData (INPTR BSTR aKey, BSTR *aValue)
 {
-    if (!aKey || !(*aKey))
+    if (!aKey)
         return E_INVALIDARG;
     if (!aValue)
@@ -1712 +1709 @@
     AutoReaderLock alock (this);
 
-    CFGHANDLE configLoader;
-
-    /* load the config file */
-    int vrc = CFGLDRLoad (&configLoader, Utf8Str (mData.mCfgFile.mName),
-                          mData.mCfgFile.mHandle,
-                          XmlSchemaNS, true, cfgLdrEntityResolver, NULL);
-    ComAssertRCRet (vrc, E_FAIL);
-
-    CFGNODE extraDataNode;
-
-    /* navigate to the right position */
-    if (VBOX_SUCCESS (CFGLDRGetNode (configLoader,
-                                     "VirtualBox/Global/ExtraData", 0,
-                                     &extraDataNode)))
-    {
-        /* check if it exists */
-        bool found = false;
-        unsigned count;
-        CFGNODE extraDataItemNode;
-        CFGLDRCountChildren (extraDataNode, "ExtraDataItem", &count);
-        for (unsigned i = 0; (i < count) && (found == false); i++)
-        {
-            Bstr name;
-            CFGLDRGetChildNode (extraDataNode, "ExtraDataItem", i, &extraDataItemNode);
-            CFGLDRQueryBSTR (extraDataItemNode, "name", name.asOutParam());
-            if (name == aKey)
+    try
+    {
+        using namespace settings;
+
+        /* load the config file */
+        File file (File::ReadWrite, mData.mCfgFile.mHandle,
+                   Utf8Str (mData.mCfgFile.mName));
+        XmlTreeBackend tree;
+
+        rc = VirtualBox::loadSettingsTree_Again (tree, file);
+        CheckComRCReturnRC (rc);
+
+        const Utf8Str key = aKey;
+
+        Key globalNode = tree.rootKey().key ("Global");
+        Key extraDataNode = globalNode.findKey ("ExtraData");
+
+        if (!extraDataNode.isNull())
+        {
+            /* check if the key exists */
+            Key::List items = extraDataNode.keys ("ExtraDataItem");
+            for (Key::List::const_iterator it = items.begin();
+                 it != items.end(); ++ it)
             {
-                found = true;
-                CFGLDRQueryBSTR (extraDataItemNode, "value", aValue);
+                if (key == (*it).stringValue ("name"))
+                {
+                    Bstr val = (*it).stringValue ("value");
+                    val.cloneTo (aValue);
+                    break;
+                }
             }
-            CFGLDRReleaseNode (extraDataItemNode);
-        }
-
-        CFGLDRReleaseNode (extraDataNode);
-    }
-
-    CFGLDRFree (configLoader);
-
-    return rc;
-}
-
-/** @note Locks this object for writing. */
-STDMETHODIMP VirtualBox::SetExtraData(INPTR BSTR aKey, INPTR BSTR aValue)
+        }
+    }
+    catch (...)
+    {
+        rc = VirtualBox::handleUnexpectedExceptions (RT_SRC_POS);
+    }
+
+    return rc;
+}
+
+/**
+ *  @note Locks this object for writing.
+ */
+STDMETHODIMP VirtualBox::SetExtraData (INPTR BSTR aKey, INPTR BSTR aValue)
 {
     if (!aKey)
-        return E_POINTER;
+        return E_INVALIDARG;
 
     AutoCaller autoCaller (this);
@@ -1770 +1769 @@
     AutoLock alock (this);
 
-    CFGHANDLE configLoader;
-
-    /* load the config file */
-    int vrc = CFGLDRLoad (&configLoader, Utf8Str (mData.mCfgFile.mName),
-                          mData.mCfgFile.mHandle,
-                          XmlSchemaNS, true, cfgLdrEntityResolver, NULL);
-    ComAssertRCRet (vrc, E_FAIL);
-
-    CFGNODE extraDataNode = 0;
-
-    vrc = CFGLDRGetNode (configLoader, "VirtualBox/Global/ExtraData", 0,
-                         &extraDataNode);
-    if (VBOX_FAILURE (vrc) && aValue)
-        vrc = CFGLDRCreateNode (configLoader, "VirtualBox/Global/ExtraData",
-                                &extraDataNode);
-
-    if (extraDataNode)
-    {
-        CFGNODE extraDataItemNode = 0;
+    try
+    {
+        using namespace settings;
+
+        /* load the config file */
+        File file (File::ReadWrite, mData.mCfgFile.mHandle,
+                   Utf8Str (mData.mCfgFile.mName));
+        XmlTreeBackend tree;
+
+        rc = VirtualBox::loadSettingsTree_ForUpdate (tree, file);
+        CheckComRCReturnRC (rc);
+
+        const Utf8Str key = aKey;
         Bstr oldVal;
 
-        unsigned count;
-        CFGLDRCountChildren (extraDataNode, "ExtraDataItem", &count);
-
-        for (unsigned i = 0; i < count; i++)
-        {
-            CFGLDRGetChildNode (extraDataNode, "ExtraDataItem", i, &extraDataItemNode);
-            Bstr name;
-            CFGLDRQueryBSTR (extraDataItemNode, "name", name.asOutParam());
-            if (name == aKey)
+        Key globalNode = tree.rootKey().key ("Global");
+        Key extraDataNode = globalNode.createKey ("ExtraData");
+        Key extraDataItemNode;
+
+        Key::List items = extraDataNode.keys ("ExtraDataItem");
+        for (Key::List::const_iterator it = items.begin();
+             it != items.end(); ++ it)
+        {
+            if (key == (*it).stringValue ("name"))
             {
-                CFGLDRQueryBSTR (extraDataItemNode, "value", oldVal.asOutParam());
+                extraDataItemNode = *it;
+                oldVal = (*it).stringValue ("value");
                 break;
             }
-            CFGLDRReleaseNode (extraDataItemNode);
-            extraDataItemNode = 0;
-        }
-
-        /*
-         *  When no key is found, oldVal is null. Note:
-         *  1. when oldVal is null, |oldVal == (BSTR) NULL| is true
-         *  2. we cannot do |oldVal != value| because it will compare
-         *  BSTR pointers instead of strings (due to type conversion ops)
-         */
-        changed = !(oldVal == aValue);
+        }
+
+        /* When no key is found, oldVal is null */
+        changed = oldVal != aValue;
 
         if (changed)
@@ -1820 +1807 @@
             /* ask for permission from all listeners */
             Bstr error;
-            if (!onExtraDataCanChange (emptyGuid, aKey, aValue, error))
+            if (!onExtraDataCanChange (Guid::Empty, aKey, aValue, error))
             {
                 const char *sep = error.isEmpty() ? "" : ": ";
@@ -1826 +1813 @@
                 LogWarningFunc (("Someone vetoed! Change refused%s%ls\n",
                                  sep, err));
-                rc = setError (E_ACCESSDENIED,
+                return setError (E_ACCESSDENIED,
                     tr ("Could not set extra data because someone refused "
                         "the requested change of '%ls' to '%ls'%s%ls"),
                     aKey, aValue, sep, err);
             }
+
+            if (aValue != NULL)
+            {
+                if (extraDataItemNode.isNull())
+                {
+                    extraDataItemNode = extraDataNode.appendKey ("ExtraDataItem");
+                    extraDataItemNode.setStringValue ("name", key);
+                }
+                extraDataItemNode.setStringValue ("value", Utf8Str (aValue));
+            }
             else
             {
-                if (aValue)
-                {
-                    if (!extraDataItemNode)
-                    {
-                        /* create a new item */
-                        CFGLDRAppendChildNode (extraDataNode, "ExtraDataItem",
-                                               &extraDataItemNode);
-                        CFGLDRSetBSTR (extraDataItemNode, "name", aKey);
-                    }
-                    CFGLDRSetBSTR (extraDataItemNode, "value", aValue);
-                }
-                else
-                {
-                    /* an old value does for sure exist here */
-                    CFGLDRDeleteNode (extraDataItemNode);
-                    extraDataItemNode = 0;
-                }
+                /* an old value does for sure exist here (XML schema
+                 * guarantees that "value" may not absent in the
+                 * <ExtraDataItem> element) */
+                Assert (!extraDataItemNode.isNull());
+                extraDataItemNode.zap();
             }
-        }
-
-        if (extraDataItemNode)
-            CFGLDRReleaseNode (extraDataItemNode);
-
-        CFGLDRReleaseNode (extraDataNode);
-
-        if (SUCCEEDED (rc) && changed)
-        {
-            char *loaderError = NULL;
-            vrc = CFGLDRSave (configLoader, &loaderError);
-            if (VBOX_FAILURE (vrc))
-            {
-                rc = setError (E_FAIL,
-                    tr ("Could not save the settings file '%ls' (%Vrc)%s%s"),
-                    mData.mCfgFile.mName.raw(), vrc,
-                    loaderError ? ".\n" : "", loaderError ? loaderError : "");
-                if (loaderError)
-                    RTMemTmpFree (loaderError);
-            }
-        }
-    }
-
-    CFGLDRFree (configLoader);
-
-    /* notification handling */
+
+            /* save settings on success */
+            rc = VirtualBox::saveSettingsTree (tree, file);
+            CheckComRCReturnRC (rc);
+        }
+    }
+    catch (...)
+    {
+        rc = VirtualBox::handleUnexpectedExceptions (RT_SRC_POS);
+    }
+
+    /* fire a notification */
     if (SUCCEEDED (rc) && changed)
-        onExtraDataChange (emptyGuid, aKey, aValue);
+        onExtraDataChange (Guid::Empty, aKey, aValue);
 
     return rc;
@@ -3398 +3369 @@
  *  and creates the relevant objects.
  *
+ *  @param aGlobal  <Global> node.
+ *
  *  @note Can be called only from #init().
  *  @note Doesn't lock anything.
  */
-HRESULT VirtualBox::loadMachines (CFGNODE aGlobal)
-{
+HRESULT VirtualBox::loadMachines (const settings::Key &aGlobal)
+{
+    using namespace settings;
+
     AutoCaller autoCaller (this);
     AssertReturn (autoCaller.state() == InInit, E_FAIL);
 
     HRESULT rc = S_OK;
-    CFGNODE machineRegistry = 0;
-    unsigned count = 0;
-
-    CFGLDRGetChildNode (aGlobal, "MachineRegistry", 0, &machineRegistry);
-    Assert (machineRegistry);
-
-    CFGLDRCountChildren(machineRegistry, "MachineEntry", &count);
-    for (unsigned i = 0; i < count && SUCCEEDED (rc); i++)
-    {
-        CFGNODE vm = 0;
-        CFGLDRGetChildNode(machineRegistry, "MachineEntry", i, &vm);
-        /* get the UUID */
-        Guid uuid;
-        CFGLDRQueryUUID(vm, "uuid", uuid.ptr());
-        /* get the machine configuration file name */
-        Bstr src;
-        CFGLDRQueryBSTR(vm, "src", src.asOutParam());
-
-        /* create a new object */
+
+    Key::List machines = aGlobal.key ("MachineRegistry").keys ("MachineEntry");
+    for (Key::List::const_iterator it = machines.begin();
+         it != machines.end(); ++ it)
+    {
+        /* required */
+        Guid uuid = (*it).value <Guid> ("uuid");
+        /* required */
+        Bstr src = (*it).stringValue ("src");
+
+        /* create a new machine object */
         ComObjPtr <Machine> machine;
         rc = machine.createObject();
@@ -3436 +3403 @@
                 rc = registerMachine (machine);
         }
-
-        CFGLDRReleaseNode(vm);
-    }
-
-    CFGLDRReleaseNode(machineRegistry);
+    }
 
     return rc;
@@ -3454 +3417 @@
  *  @note Doesn't lock anything.
  */
-HRESULT VirtualBox::loadDisks (CFGNODE aGlobal)
-{
+HRESULT VirtualBox::loadDisks (const settings::Key &aGlobal)
+{
+    using namespace settings;
+
     AutoCaller autoCaller (this);
     AssertReturn (autoCaller.state() == InInit, E_FAIL);
 
     HRESULT rc = S_OK;
-    CFGNODE registryNode = 0;
-
-    CFGLDRGetChildNode (aGlobal, "DiskRegistry", 0, &registryNode);
-    ComAssertRet (registryNode, E_FAIL);
-
-    const char *ImagesNodes[] = { "HardDisks", "DVDImages", "FloppyImages" };
-
-    for (size_t node = 0; node < ELEMENTS (ImagesNodes) && SUCCEEDED (rc); node ++)
-    {
-        CFGNODE imagesNode = 0;
-        CFGLDRGetChildNode (registryNode, ImagesNodes [node], 0, &imagesNode);
-
-        // all three nodes are optional
-        if (!imagesNode)
+
+    Key registry = aGlobal.key ("DiskRegistry");
+
+    const char *kMediaNodes[] = { "HardDisks", "DVDImages", "FloppyImages" };
+
+    for (size_t n = 0; n < ELEMENTS (kMediaNodes); ++ n)
+    {
+        /* All three media nodes are optional */
+        Key node = registry.findKey (kMediaNodes [n]);
+        if (node.isNull())
             continue;
 
-        if (node == 0) // HardDisks node
-            rc = loadHardDisks (imagesNode);
-        else
-        {
-            unsigned count = 0;
-            CFGLDRCountChildren (imagesNode, "Image", &count);
-            for (unsigned i = 0; i < count && SUCCEEDED (rc); ++ i)
+        if (n == 0)
+        {
+            /* HardDisks node */
+            rc = loadHardDisks (node);
+            continue;
+        }
+
+        Key::List images = node.keys ("Image");
+        for (Key::List::const_iterator it = images.begin();
+             it != images.end(); ++ it)
+        {
+            /* required */
+            Guid uuid = (*it).value <Guid> ("uuid");
+            /* required */
+            Bstr src = (*it).stringValue ("src");
+
+            switch (n)
             {
-                CFGNODE imageNode = 0;
-                CFGLDRGetChildNode (imagesNode, "Image", i, &imageNode);
-                ComAssertBreak (imageNode, rc = E_FAIL);
-
-                Guid uuid; // uuid (required)
-                CFGLDRQueryUUID (imageNode, "uuid", uuid.ptr());
-                Bstr src; // source (required)
-                CFGLDRQueryBSTR (imageNode, "src", src.asOutParam());
-
-                switch (node)
+                case 1: /* DVDImages */
                 {
-                    case 1: // DVDImages
-                    {
-                        ComObjPtr <DVDImage> dvdImage;
-                        dvdImage.createObject();
-                        rc = dvdImage->init (this, src, TRUE /* isRegistered */, uuid);
-                        if (SUCCEEDED (rc))
-                            rc = registerDVDImage (dvdImage, TRUE /* aOnStartUp */);
-
-                        break;
-                    }
-                    case 2: // FloppyImages
-                    {
-                        ComObjPtr <FloppyImage> floppyImage;
-                        floppyImage.createObject();
-                        rc = floppyImage->init (this, src, TRUE /* isRegistered */, uuid);
-                        if (SUCCEEDED (rc))
-                            rc = registerFloppyImage (floppyImage, TRUE /* aOnStartUp */);
-
-                        break;
-                    }
-                    default:
-                        AssertFailed();
+                    ComObjPtr <DVDImage> image;
+                    image.createObject();
+                    rc = image->init (this, src, TRUE /* isRegistered */, uuid);
+                    if (SUCCEEDED (rc))
+                        rc = registerDVDImage (image, TRUE /* aOnStartUp */);
+
+                    break;
                 }
-
-                CFGLDRReleaseNode (imageNode);
+                case 2: /* FloppyImages */
+                {
+                    ComObjPtr <FloppyImage> image;
+                    image.createObject();
+                    rc = image->init (this, src, TRUE /* isRegistered */, uuid);
+                    if (SUCCEEDED (rc))
+                        rc = registerFloppyImage (image, TRUE /* aOnStartUp */);
+
+                    break;
+                }
+                default:
+                    AssertFailed();
             }
-        }
-
-        CFGLDRReleaseNode (imagesNode);
-    }
-
-    CFGLDRReleaseNode (registryNode);
+
+            CheckComRCBreakRC (rc);
+        }
+
+        CheckComRCBreakRC (rc);
+    }
 
     return rc;
@@ -3535 +3492 @@
  *  Note that all loaded hard disks register themselves within this VirtualBox.
  *
- *  @param aNode        <HardDisks> node
+ *  @param aNode        <HardDisks> node.
  *
  *  @note Can be called only from #init().
  *  @note Doesn't lock anything.
  */
-HRESULT VirtualBox::loadHardDisks (CFGNODE aNode)
-{
+HRESULT VirtualBox::loadHardDisks (const settings::Key &aNode)
+{
+    using namespace settings;
+
     AutoCaller autoCaller (this);
     AssertReturn (autoCaller.state() == InInit, E_FAIL);
 
-    AssertReturn (aNode, E_INVALIDARG);
+    AssertReturn (!aNode.isNull(), E_INVALIDARG);
 
     HRESULT rc = S_OK;
 
-    unsigned count = 0;
-    CFGLDRCountChildren (aNode, "HardDisk", &count);
-    for (unsigned i = 0; i < count && SUCCEEDED (rc); ++ i)
-    {
-        CFGNODE hdNode = 0;
-
-        CFGLDRGetChildNode (aNode, "HardDisk", i, &hdNode);
-        ComAssertBreak (hdNode, rc = E_FAIL);
-
-        {
-            CFGNODE storageNode = 0;
-
-            // detect the type of the hard disk
-            // (either one of HVirtualDiskImage, HISCSIHardDisk or HPhysicalVolume
-            do
+    Key::List disks = aNode.keys ("HardDisk");
+    for (Key::List::const_iterator it = disks.begin();
+         it != disks.end(); ++ it)
+    {
+        Key storageNode;
+
+        /* detect the type of the hard disk (either one of VirtualDiskImage,
+         * ISCSIHardDisk, VMDKImage or HCustomHardDisk) */
+
+        do
+        {
+            storageNode = (*it).findKey ("VirtualDiskImage");
+            if (!storageNode.isNull())
             {
-                CFGLDRGetChildNode (hdNode, "VirtualDiskImage", 0, &storageNode);
-                if (storageNode)
-                {
-                    ComObjPtr <HVirtualDiskImage> vdi;
-                    vdi.createObject();
-                    rc = vdi->init (this, NULL, hdNode, storageNode);
-                    break;
-                }
-
-                CFGLDRGetChildNode (hdNode, "ISCSIHardDisk", 0, &storageNode);
-                if (storageNode)
-                {
-                    ComObjPtr <HISCSIHardDisk> iscsi;
-                    iscsi.createObject();
-                    rc = iscsi->init (this, hdNode, storageNode);
-                    break;
-                }
-
-                CFGLDRGetChildNode (hdNode, "VMDKImage", 0, &storageNode);
-                if (storageNode)
-                {
-                    ComObjPtr <HVMDKImage> vmdk;
-                    vmdk.createObject();
-                    rc = vmdk->init (this, NULL, hdNode, storageNode);
-                    break;
-                }
-                CFGLDRGetChildNode (hdNode, "CustomHardDisk", 0, &storageNode);
-                if (storageNode)
-                {
-                    ComObjPtr <HCustomHardDisk> custom;
-                    custom.createObject();
-                    rc = custom->init (this, NULL, hdNode, storageNode);
-                    break;
-                }
-
-                /// @todo (dmik) later
-//                CFGLDRGetChildNode (hdNode, "PhysicalVolume", 0, &storageNode);
-//                if (storageNode)
-//                {
-//                    break;
-//                }
-
-                ComAssertMsgFailedBreak (("No valid hard disk storage node!\n"),
-                                         rc = E_FAIL);
+                ComObjPtr <HVirtualDiskImage> vdi;
+                vdi.createObject();
+                rc = vdi->init (this, NULL, (*it), storageNode);
+                break;
             }
-            while (0);
-
-            if (storageNode)
-                CFGLDRReleaseNode (storageNode);
-        }
-
-        CFGLDRReleaseNode (hdNode);
-    }
-
-    return rc;
-}
-
-/**
- *  Helper function to write out the configuration to XML.
- *
- *  @note Locks objects!
- */
-HRESULT VirtualBox::saveConfig()
+
+            storageNode = (*it).findKey ("ISCSIHardDisk");
+            if (!storageNode.isNull())
+            {
+                ComObjPtr <HISCSIHardDisk> iscsi;
+                iscsi.createObject();
+                rc = iscsi->init (this, (*it), storageNode);
+                break;
+            }
+
+            storageNode = (*it).findKey ("VMDKImage");
+            if (!storageNode.isNull())
+            {
+                ComObjPtr <HVMDKImage> vmdk;
+                vmdk.createObject();
+                rc = vmdk->init (this, NULL, (*it), storageNode);
+                break;
+            }
+
+            storageNode = (*it).findKey ("CustomHardDisk");
+            if (!storageNode.isNull())
+            {
+                ComObjPtr <HCustomHardDisk> custom;
+                custom.createObject();
+                rc = custom->init (this, NULL, (*it), storageNode);
+                break;
+            }
+
+            ComAssertMsgFailedBreak (("No valid hard disk storage node!\n"),
+                                     rc = E_FAIL);
+        }
+        while (0);
+    }
+
+    return rc;
+}
+
+/**
+ *  Helper function to write out the configuration tree.
+ *
+ *  @note Locks objects for reading!
+ */
+HRESULT VirtualBox::saveSettings()
 {
     AutoCaller autoCaller (this);
     AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
 
-    ComAssertRet (!!mData.mCfgFile.mName, E_FAIL);
+    AssertReturn (!!mData.mCfgFile.mName, E_FAIL);
 
     HRESULT rc = S_OK;
 
-    AutoLock alock (this);
-
-    CFGHANDLE configLoader;
-
-    /* load the config file */
-    int vrc = CFGLDRLoad (&configLoader, Utf8Str (mData.mCfgFile.mName),
-                          mData.mCfgFile.mHandle,
-                          XmlSchemaNS, true, cfgLdrEntityResolver, NULL);
-    ComAssertRCRet (vrc, E_FAIL);
-
-    const char * Global = "VirtualBox/Global";
-    CFGNODE global;
-
-    vrc = CFGLDRGetNode(configLoader, Global, 0, &global);
-    if (VBOX_FAILURE (vrc))
-        CFGLDRCreateNode (configLoader, Global, &global);
-
-    do
-    {
-        ComAssertBreak (global, rc = E_FAIL);
+    AutoReaderLock alock (this);
+
+    try
+    {
+        using namespace settings;
+
+        File file (File::ReadWrite, mData.mCfgFile.mHandle,
+                   Utf8Str (mData.mCfgFile.mName));
+        XmlTreeBackend tree;
+
+        rc = VirtualBox::loadSettingsTree_ForUpdate (tree, file);
+        CheckComRCThrowRC (rc);
+
+        Key global = tree.rootKey().createKey ("Global");
 
         /* machines */
-        do
-        {
-            const char *Registry = "MachineRegistry";
-            const char *Entry = "MachineEntry";
-            CFGNODE registryNode = NULL;
-
+        {
             /* first, delete the entire machine registry */
-            if (VBOX_SUCCESS (CFGLDRGetChildNode (global, Registry, 0, &registryNode)))
-                CFGLDRDeleteNode (registryNode);
-
+            Key registryNode = global.findKey ("MachineRegistry");
+            if (!registryNode.isNull())
+                registryNode.zap();
             /* then, recreate it */
-            CFGLDRCreateChildNode (global, Registry, &registryNode);
+            registryNode = global.createKey ("MachineRegistry");
 
             /* write out the machines */
@@ -3676 +3607 @@
                  ++ it)
             {
-                /// @todo (dmik) move this part to Machine for better incapsulation
-
-                CFGNODE entryNode = NULL;
-                CFGLDRAppendChildNode (registryNode, Entry, &entryNode);
+                Key entryNode = registryNode.appendKey ("MachineEntry");
                 rc = (*it)->saveRegistryEntry (entryNode);
-                CFGLDRReleaseNode (entryNode);
-                CheckComRCBreakRC (rc);
+                CheckComRCThrowRC (rc);
             }
-
-            CFGLDRReleaseNode (registryNode);
-        }
-        while (0);
-        CheckComRCBreakRC (rc);
+        }
 
         /* disk images */
-        do
-        {
-            CFGNODE registryNode = 0;
-            CFGLDRGetChildNode (global, "DiskRegistry", 0, &registryNode);
+        {
             /* first, delete the entire disk image registr */
-            if (registryNode)
-                CFGLDRDeleteNode (registryNode);
+            Key registryNode = global.findKey ("DiskRegistry");
+            if (!registryNode.isNull())
+                registryNode.zap();
             /* then, recreate it */
-            CFGLDRCreateChildNode (global, "DiskRegistry", &registryNode);
-            ComAssertBreak (registryNode, rc = E_FAIL);
+            registryNode = global.createKey ("DiskRegistry");
 
             /* write out the hard disks */
             {
-                CFGNODE imagesNode = 0;
-                CFGLDRCreateChildNode (registryNode, "HardDisks", &imagesNode);
+                Key imagesNode = registryNode.createKey ("HardDisks");
                 rc = saveHardDisks (imagesNode);
-                CFGLDRReleaseNode (imagesNode);
-                CheckComRCBreakRC (rc);
+                CheckComRCThrowRC (rc);
             }
 
             /* write out the CD/DVD images */
             {
-                CFGNODE imagesNode = 0;
-                CFGLDRCreateChildNode (registryNode, "DVDImages", &imagesNode);
+                Key imagesNode = registryNode.createKey ("DVDImages");
 
                 for (DVDImageList::iterator it = mData.mDVDImages.begin();
@@ -3722 +3639 @@
                     ComObjPtr <DVDImage> dvd = *it;
                     /* no need to lock: fields are constant */
-                    CFGNODE imageNode = 0;
-                    CFGLDRAppendChildNode (imagesNode, "Image", &imageNode);
-                    CFGLDRSetUUID (imageNode, "uuid", dvd->id());
-                    CFGLDRSetBSTR (imageNode, "src", dvd->filePath());
-                    CFGLDRReleaseNode (imageNode);
+                    Key imageNode = imagesNode.appendKey ("Image");
+                    imageNode.setValue <Guid> ("uuid", dvd->id());
+                    imageNode.setValue <Bstr> ("src", dvd->filePath());
                 }
-
-                CFGLDRReleaseNode (imagesNode);
             }
 
             /* write out the floppy images */
             {
-                CFGNODE imagesNode = 0;
-                CFGLDRCreateChildNode (registryNode, "FloppyImages", &imagesNode);
+                Key imagesNode = registryNode.createKey ("FloppyImages");
 
                 for (FloppyImageList::iterator it = mData.mFloppyImages.begin();
@@ -3743 +3655 @@
                     ComObjPtr <FloppyImage> fd = *it;
                     /* no need to lock: fields are constant */
-                    CFGNODE imageNode = 0;
-                    CFGLDRAppendChildNode (imagesNode, "Image", &imageNode);
-                    CFGLDRSetUUID (imageNode, "uuid", fd->id());
-                    CFGLDRSetBSTR (imageNode, "src", fd->filePath());
-                    CFGLDRReleaseNode (imageNode);
+                    Key imageNode = imagesNode.appendKey ("Image");
+                    imageNode.setValue <Guid> ("uuid", fd->id());
+                    imageNode.setValue <Bstr> ("src", fd->filePath());
                 }
-
-                CFGLDRReleaseNode (imagesNode);
             }
-
-            CFGLDRReleaseNode (registryNode);
-        }
-        while (0);
-        CheckComRCBreakRC (rc);
-
-        do
-        {
-            /* host data (USB filters) */
-            rc = mData.mHost->saveSettings (global);
-            CheckComRCBreakRC (rc);
-
-            rc = mData.mSystemProperties->saveSettings (global);
-            CheckComRCBreakRC (rc);
-        }
-        while (0);
-    }
-    while (0);
-
-    if (global)
-        CFGLDRReleaseNode (global);
-
-    if (SUCCEEDED (rc))
-    {
-        char *loaderError = NULL;
-        vrc = CFGLDRSave (configLoader, &loaderError);
-        if (VBOX_FAILURE (vrc))
-        {
-            rc = setError (E_FAIL,
-                tr ("Could not save the settings file '%ls' (%Vrc)%s%s"),
-                mData.mCfgFile.mName.raw(), vrc,
-                loaderError ? ".\n" : "", loaderError ? loaderError : "");
-            if (loaderError)
-                RTMemTmpFree (loaderError);
-        }
-    }
-
-    CFGLDRFree(configLoader);
+        }
+
+        /* host data (USB filters) */
+        rc = mData.mHost->saveSettings (global);
+        CheckComRCThrowRC (rc);
+
+        rc = mData.mSystemProperties->saveSettings (global);
+        CheckComRCThrowRC (rc);
+
+        /* save the settings on success */
+        rc = VirtualBox::saveSettingsTree (tree, file);
+        CheckComRCThrowRC (rc);
+    }
+    catch (HRESULT err)
+    {
+        /* we assume that error info is set by the thrower */
+        rc = err;
+    }
+    catch (...)
+    {
+        rc = VirtualBox::handleUnexpectedExceptions (RT_SRC_POS);
+    }
 
     return rc;
@@ -3797 +3689 @@
  *  Saves all hard disks to the given <HardDisks> node.
  *
- *  @param aNode        <HardDisks> node
+ *  @param aNode        <HardDisks> node.
  *
  *  @note Locks this object for reding.
  */
-HRESULT VirtualBox::saveHardDisks (CFGNODE aNode)
-{
-    AssertReturn (aNode, E_INVALIDARG);
+HRESULT VirtualBox::saveHardDisks (settings::Key &aNode)
+{
+    using namespace settings;
+
+    AssertReturn (!aNode.isNull(), E_INVALIDARG);
 
     HRESULT rc = S_OK;
@@ -3810 +3704 @@
 
     for (HardDiskList::const_iterator it = mData.mHardDisks.begin();
-         it != mData.mHardDisks.end() && SUCCEEDED (rc);
+         it != mData.mHardDisks.end();
          ++ it)
     {
@@ -3816 +3710 @@
         AutoReaderLock hdLock (hd);
 
-        CFGNODE hdNode = 0;
-        CFGLDRAppendChildNode (aNode, "HardDisk", &hdNode);
-        ComAssertBreak (hdNode, rc = E_FAIL);
-
-        CFGNODE storageNode = 0;
+        Key hdNode = aNode.appendKey ("HardDisk");
 
         switch (hd->storageType())
@@ -3826 +3716 @@
             case HardDiskStorageType_VirtualDiskImage:
             {
-                CFGLDRAppendChildNode (hdNode, "VirtualDiskImage", &storageNode);
-                ComAssertBreak (storageNode, rc = E_FAIL);
+                Key storageNode = hdNode.createKey ("VirtualDiskImage");
                 rc = hd->saveSettings (hdNode, storageNode);
                 break;
@@ -3834 +3723 @@
             case HardDiskStorageType_ISCSIHardDisk:
             {
-                CFGLDRAppendChildNode (hdNode, "ISCSIHardDisk", &storageNode);
-                ComAssertBreak (storageNode, rc = E_FAIL);
+                Key storageNode = hdNode.createKey ("ISCSIHardDisk");
                 rc = hd->saveSettings (hdNode, storageNode);
                 break;
@@ -3842 +3730 @@
             case HardDiskStorageType_VMDKImage:
             {
-                CFGLDRAppendChildNode (hdNode, "VMDKImage", &storageNode);
-                ComAssertBreak (storageNode, rc = E_FAIL);
+                Key storageNode = hdNode.createKey ("VMDKImage");
                 rc = hd->saveSettings (hdNode, storageNode);
                 break;
@@ -3849 +3736 @@
             case HardDiskStorageType_CustomHardDisk:
             {
-                CFGLDRAppendChildNode (hdNode, "CustomHardDisk", &storageNode);
-                ComAssertBreak (storageNode, rc = E_FAIL);
+                Key storageNode = hdNode.createKey ("CustomHardDisk");
                 rc = hd->saveSettings (hdNode, storageNode);
                 break;
             }
-
-            /// @todo (dmik) later
-//            case HardDiskStorageType_PhysicalVolume:
-//            {
-//                break;
-//            }
-        }
-
-        if (storageNode)
-            CFGLDRReleaseNode (storageNode);
-
-        CFGLDRReleaseNode (hdNode);
+        }
+
+        CheckComRCBreakRC (rc);
     }
 
@@ -3926 +3803 @@
 
     if (autoCaller.state() != InInit)
-        rc = saveConfig();
+        rc = saveSettings();
 
     return rc;
@@ -3971 +3848 @@
     /// @todo (dmik) optimize later to save only the <HardDisks> node
     if (aFlags != RHD_OnStartUp)
-        rc = saveConfig();
+        rc = saveSettings();
 
     return rc;
@@ -4031 +3908 @@
     /* save the global config file anyway (already unregistered) */
     /// @todo (dmik) optimize later to save only the <HardDisks> node
-    HRESULT rc2 = saveConfig();
+    HRESULT rc2 = saveSettings();
     if (SUCCEEDED (rc))
         rc = rc2;
@@ -4154 +4031 @@
     }
 
-    HRESULT rc = saveConfig();
-
-    return rc;
+    HRESULT rc = saveSettings();
+
+    return rc;
+}
+
+/** 
+ * Helper method to load the setting tree and turn expected exceptions into
+ * COM errors, according to arguments.
+ * 
+ * Note that this method will not catch unexpected errors so it may still
+ * throw something.
+ *
+ * @param aTree             Tree to load into settings.
+ * @param aFile             File to load settings from.
+ * @param aValidate         @c @true to enable tree validation.
+ * @param aCatchLoadErrors  @c true to catch exceptions caused by file
+ *                          access or validation errors.
+ * @param aAddDefaults      @c true to cause the substitution of default
+ *                          values for for missing attributes that have
+ *                          defaults in the XML schema.
+ */
+/* static */
+HRESULT VirtualBox::loadSettingsTree (settings::XmlTreeBackend &aTree,
+                                      settings::File &aFile,
+                                      bool aValidate,
+                                      bool aCatchLoadErrors,
+                                      bool aAddDefaults)
+{
+    using namespace settings;
+
+    try
+    {
+        SettingsInputResolver resolver = SettingsInputResolver();
+
+        aTree.setInputResolver (resolver);
+        aTree.read (aFile, aValidate ? VBOX_XML_SCHEMA : NULL,
+                    aAddDefaults ? XmlTreeBackend::Read_AddDefaults : 0);
+        aTree.resetInputResolver();
+    }
+    catch (const EIPRTFailure &err)
+    {
+        if (!aCatchLoadErrors)
+            throw;
+
+        return setError (E_FAIL,
+                         tr ("Could not load the settings file '%s' (%Vrc)"),
+                         aFile.uri(), err.rc());
+    }
+    catch (const XmlTreeBackend::Error &err)
+    {
+        Assert (err.what() != NULL);
+
+        if (!aCatchLoadErrors)
+            throw;
+
+        return setError (E_FAIL,
+                         tr ("Could not load the settings file '%s'.\n%s"),
+                         aFile.uri(),
+                         err.what() ? err.what() : "Unknown error");
+    }
+
+    return S_OK;
+}
+
+/** 
+ * Helper method to save the settings tree and turn expected exceptions to COM
+ * errors.
+ *
+ * Note that this method will not catch unexpected errors so it may still
+ * throw something.
+ * 
+ * @param aTree Tree to save.
+ * @param aFile File to save the tree to.
+ */
+/* static */
+HRESULT VirtualBox::saveSettingsTree (settings::TreeBackend &aTree,
+                                             settings::File &aFile)
+{
+    using namespace settings;
+
+    try
+    {
+        aTree.write (aFile);
+    }
+    catch (const EIPRTFailure &err)
+    {
+        /* this is the only expected exception for now */
+        return setError (E_FAIL,
+                         tr ("Could not save the settings file '%s' (%Vrc)"),
+                         aFile.uri(), err.rc());
+    }
+
+    return S_OK;
+}
+
+/** 
+ * Handles unexpected exceptions by turning them into COM errors in release
+ * builds or by hitting a breakpoint in the release builds.
+ *
+ * Usage pattern:
+ * @code
+        try
+        {
+            // ...
+        }
+        catch (LaLalA)
+        {
+            // ...
+        }
+        catch (...)
+        {
+            rc = VirtualBox::handleUnexpectedExceptions (RT_SRC_POS);
+        }
+ * @endcode
+ * 
+ * @param RT_SRC_POS_DECL "RT_SRC_POS" macro instantiation.
+ */
+/* static */
+HRESULT VirtualBox::handleUnexpectedExceptions (RT_SRC_POS_DECL)
+{
+    try
+    {
+        /* rethrow the current exception */
+        throw;
+    }
+    catch (const std::exception &err)
+    {
+        ComAssertMsgFailedPos (("Unexpected exception '%s' (%s)\n",
+                                typeid (err).name(), err.what()),
+                               pszFile, iLine, pszFunction);
+        return E_FAIL;
+    }
+    catch (...)
+    {
+        ComAssertMsgFailedPos (("Unknown exception\n"),
+                               pszFile, iLine, pszFunction);
+        return E_FAIL;
+    }
+
+    /* should not get here */
+    AssertFailed();
+    return E_FAIL;
 }
 
@@ -4187 +4203 @@
     /* save global config file if we're supposed to */
     if (!aOnStartUp)
-        rc = saveConfig();
+        rc = saveSettings();
 
     return rc;
@@ -4220 +4236 @@
     /* save global config file if we're supposed to */
     if (!aOnStartUp)
-        rc = saveConfig();
+        rc = saveSettings();
 
     return rc;

trunk/src/VBox/Main/glue/com.cpp

@@ +1 @@
+/* $Id$ */
+
 /** @file
  * MS COM / XPCOM Abstraction Layer
@@ -41 +43 @@
 #include "VBox/com/com.h"
 #include "VBox/com/assert.h"
+
+#include <VBox/com/Guid.h>
 
 
@@ -182 +186 @@
 }
 
+/* static */
+const Guid Guid::Empty; /* default ctor is OK */ 
+
 } /* namespace com */

trunk/src/VBox/Main/glue/string.cpp

@@ +1 @@
+/* $Id$ */
+
 /** @file
  *
@@ -19 +21 @@
 #include "VBox/com/string.h"
 
+#include <iprt/err.h>
+
 namespace com
 {
+
+/* static */
+const Bstr Bstr::Null; /* default ctor is OK */ 
+
+/* static */
+const Utf8Str Utf8Str::Null; /* default ctor is OK */
 
 struct FormatData
@@ -86 +96 @@
 
 } /* namespace com */
-

trunk/src/VBox/Main/idl/VirtualBox.xidl

@@ -1588 +1588 @@
     <method name="getNextExtraDataKey">
       <desc>
-        Returns the extra data key name following the supplied key.
-        An error is returned if the supplied key does not exist.
-        @c NULL is returned if the supplied key is the last key.
-        When supplying @c NULL for the key, the first item is returned.
-        @a nextValue is an optional parameter and if supplied, the next
-        key's value is returned in it.
+        Returns the global extra data key name following the supplied key.
+
+        An error is returned if the supplied @a key does not exist. @c NULL is
+        returned in @a nextKey if the supplied key is the last key. When
+        supplying @c NULL for the @a key, the first key item is returned in @a
+        nextKey (if there is any). @a nextValue is an optional parameter and
+        if supplied, the next key's value is returned in it.
       </desc>
       <param name="key" type="wstring" dir="in">
@@ -1608 +1609 @@
     <method name="getExtraData">
       <desc>
-        Returns associated extra data.
-        If the reuqested key does not exist, this function will
-        succeed and return @c null in the @a value argument.
+        Returns associated global extra data.
+
+        If the reuqested data @a key does not exist, this function will
+        succeed and return @c NULL in the @a value argument.
       </desc>
       <param name="key" type="wstring" dir="in">
@@ -1622 +1624 @@
     <method name="setExtraData">
       <desc>
-        Sets associated extra data.
-        If you pass @c NULL as a key @a vaule, the given key will be
+        Sets associated global extra data.
+
+        If you pass @c NULL as a key @a vaule, the given @a key will be
         deleted.
-        <note>
-          This method can be called outside a machine session and
-          therefore it's a caller's responsibility to handle race
-          condition when several clients change the same key at the
-          same time.
+
+        <note>
+          Before performing the actual data change, this method will ask all
+          registered callbacks using the
+          <link to="IVirtualBoxCallback::onExtraDataCanChange()"/>
+          notification for a permission. If one of the callbacks refuses the
+          new value, the change will not be performed.
+        </note>
+        <note>
+          On success, the
+          <link to="IVirtualBoxCallback::onExtraDataChange()"/> notification
+          is called to inform all registered callbacks about a successful data
+          change.
         </note>
       </desc>
@@ -2850 +2861 @@
     <method name="getNextExtraDataKey">
       <desc>
-        Returns the extra data key name following the supplied key.
-        An error is returned if the supplied key does not exist.
-        NULL is returned if the supplied key is the last key.
-        When supplying NULL for the key, the first item is returned.
-        NextValue is an optional parameter and if supplied, the next
-        key's value is returned as well.
-      </desc>
-      <param name="key" type="wstring" dir="in"/>
-      <param name="nextKey" type="wstring" dir="out"/>
-      <param name="nextValue" type="wstring" dir="out"/>
+        Returns the machine-specific extra data key name following the
+        supplied key.
+
+        An error is returned if the supplied @a key does not exist. @c NULL is
+        returned in @a nextKey if the supplied key is the last key. When
+        supplying @c NULL for the @a key, the first key item is returned in @a
+        nextKey (if there is any). @a nextValue is an optional parameter and
+        if supplied, the next key's value is returned in it.
+      </desc>
+      <param name="key" type="wstring" dir="in">
+        <desc>Name of the data key to follow.</desc>
+      </param>
+      <param name="nextKey" type="wstring" dir="out">
+        <desc>Name of the next data key.</desc>
+      </param>
+      <param name="nextValue" type="wstring" dir="out">
+        <desc>Value of the next data key.</desc>
+      </param>
     </method>
 
     <method name="getExtraData">
-      <desc>Returns associated extra data.</desc>
-      <param name="key" type="wstring" dir="in"/>
-      <param name="value" type="wstring" dir="return"/>
+      <desc>
+        Returns associated machine-specific extra data.
+
+        If the reuqested data @a key does not exist, this function will
+        succeed and return @c NULL in the @a value argument.
+      </desc>
+      <param name="key" type="wstring" dir="in">
+        <desc>Name of the data key to get.</desc>
+      </param>
+      <param name="value" type="wstring" dir="return">
+        <desc>Value of the requested data key.</desc>
+      </param>
     </method>
 
     <method name="setExtraData">
-      <desc>Sets associated extra data.</desc>
-      <param name="key" type="wstring" dir="in"/>
-      <param name="value" type="wstring" dir="in"/>
+      <desc>
+        Sets associated machine-specific extra data.
+
+        If you pass @c NULL as a key @a vaule, the given @a key will be
+        deleted.
+
+        <note>
+          Before performing the actual data change, this method will ask all
+          registered callbacks using the
+          <link to="IVirtualBoxCallback::onExtraDataCanChange()"/>
+          notification for a permission. If one of the callbacks refuses the
+          new value, the change will not be performed.
+        </note>
+        <note>
+          On success, the
+          <link to="IVirtualBoxCallback::onExtraDataChange()"/> notification
+          is called to inform all registered callbacks about a successful data
+          change.
+        </note>
+        <note>
+          This method can be called outside the machine session and therefore
+          it's a caller's responsibility to handle possible race conditions
+          when several clients change the same key at the same time.
+        </note>
+      </desc>
+      <param name="key" type="wstring" dir="in">
+        <desc>Name of the data key to set.</desc>
+      </param>
+      <param name="value" type="wstring" dir="in">
+        <desc>Value to assign to the key.</desc>
+      </param>
     </method>
 

trunk/src/VBox/Main/include/AudioAdapterImpl.h

@@ +1 @@
+/* $Id$ */
+
 /** @file
  *
@@ -80 +82 @@
     // public methods only for internal purposes
 
+    HRESULT loadSettings (const settings::Key &aMachineNode);
+    HRESULT saveSettings (settings::Key &aMachineNode);
+
     bool isModified() { AutoLock alock (this); return mData.isBackedUp(); }
     bool isReallyModified() { AutoLock alock (this); return mData.hasActualChanges(); }

trunk/src/VBox/Main/include/BIOSSettingsImpl.h

@@ +1 @@
+/* $Id$ */
+
 /** @file
  *
@@ -116 +118 @@
     // public methods only for internal purposes
 
+    HRESULT loadSettings (const settings::Key &aMachineNode);
+    HRESULT saveSettings (settings::Key &aMachineNode);
+
     const Backupable <Data> &data() const { return mData; }
 

trunk/src/VBox/Main/include/DVDDriveImpl.h

@@ +1 @@
+/* $Id$ */
+
 /** @file
  *
@@ -90 +92 @@
     // public methods only for internal purposes
 
+    HRESULT loadSettings (const settings::Key &aMachineNode);
+    HRESULT saveSettings (settings::Key &aMachineNode);
+
     bool isModified() { AutoLock alock (this); return mData.isBackedUp(); }
     bool isReallyModified() { AutoLock alock (this); return mData.hasActualChanges(); }

trunk/src/VBox/Main/include/FloppyDriveImpl.h

@@ +1 @@
+/* $Id$ */
+
 /** @file
  *
@@ -91 +93 @@
     // public methods only for internal purposes
 
+    HRESULT loadSettings (const settings::Key &aMachineNode);
+    HRESULT saveSettings (settings::Key &aMachineNode);
+
     bool isModified() { AutoLock alock (this); return mData.isBackedUp(); }
     bool isReallyModified() { AutoLock alock (this); return mData.hasActualChanges(); }

trunk/src/VBox/Main/include/HardDiskImpl.h

@@ +1 @@
+/* $Id$ */
+
 /** @file
  *
@@ -22 +24 @@
 #include "Collection.h"
 
-#include <VBox/cfgldr.h>
 #include <VBox/VBoxHDD-new.h>
 
@@ -134 +135 @@
     virtual HRESULT getAccessible (Bstr &aAccessError) = 0;
 
-    virtual HRESULT saveSettings (CFGNODE aHDNode, CFGNODE aStorageNode) = 0;
+    virtual HRESULT saveSettings (settings::Key &aHDNode, settings::Key &aStorageNode) = 0;
 
     virtual void updatePath (const char *aOldPath, const char *aNewPath) {}
@@ -180 +181 @@
 protected:
 
-    HRESULT loadSettings (CFGNODE aHDNode);
-    HRESULT saveSettings (CFGNODE aHDNode);
+    HRESULT loadSettings (const settings::Key &aHDNode);
+    HRESULT saveSettings (settings::Key &aHDNode);
 
     /** weak VirualBox parent */
@@ -234 +235 @@
 
     HRESULT init (VirtualBox *aVirtualBox, HardDisk *aParent,
-                  CFGNODE aHDNode, CFGNODE aVDINode);
+                  const settings::Key &aHDNode, const settings::Key &aVDINode);
     HRESULT init (VirtualBox *aVirtualBox, HardDisk *aParent,
                   const BSTR aFilePath, BOOL aRegistered = FALSE);
@@ -263 +264 @@
     HRESULT getAccessible (Bstr &aAccessError);
 
-    HRESULT saveSettings (CFGNODE aHDNode, CFGNODE aStorageNode);
+    HRESULT saveSettings (settings::Key &aHDNode, settings::Key &aStorageNode);
 
     void updatePath (const char *aOldPath, const char *aNewPath);
@@ -359 +360 @@
 
     HRESULT init (VirtualBox *aVirtualBox,
-                  CFGNODE aHDNode, CFGNODE aISCSINode);
+                  const settings::Key &aHDNode, const settings::Key &aISCSINode);
     HRESULT init (VirtualBox *aVirtualBox);
     void uninit();
@@ -395 +396 @@
     HRESULT getAccessible (Bstr &aAccessError);
 
-    HRESULT saveSettings (CFGNODE aHDNode, CFGNODE aStorageNode);
+    HRESULT saveSettings (settings::Key &aHDNode, settings::Key &aStorageNode);
 
     Bstr toString (bool aShort = false);
@@ -456 +457 @@
 
     HRESULT init (VirtualBox *aVirtualBox, HardDisk *aParent,
-                  CFGNODE aHDNode, CFGNODE aVMDKNode);
+                  const settings::Key &aHDNode, const settings::Key &aVMDKNode);
     HRESULT init (VirtualBox *aVirtualBox, HardDisk *aParent,
                   INPTR BSTR aFilePath, BOOL aRegistered = FALSE);
@@ -485 +486 @@
     HRESULT getAccessible (Bstr &aAccessError);
 
-    HRESULT saveSettings (CFGNODE aHDNode, CFGNODE aStorageNode);
+    HRESULT saveSettings (settings::Key &aHDNode, settings::Key &aStorageNode);
 
     void updatePath (const char *aOldPath, const char *aNewPath);
@@ -569 +570 @@
 
     HRESULT init (VirtualBox *aVirtualBox, HardDisk *aParent,
-                  CFGNODE aHDNode, CFGNODE aCustomNode);
+                  const settings::Key &aHDNode, const settings::Key &aCustomNode);
     HRESULT init (VirtualBox *aVirtualBox, HardDisk *aParent,
                   INPTR BSTR aLocation, BOOL aRegistered = FALSE);
@@ -598 +599 @@
     HRESULT getAccessible (Bstr &aAccessError);
 
-    HRESULT saveSettings (CFGNODE aHDNode, CFGNODE aStorageNode);
+    HRESULT saveSettings (settings::Key &aHDNode, settings::Key &aStorageNode);
 
     Bstr toString (bool aShort = false);

trunk/src/VBox/Main/include/HostImpl.h

@@ +1 @@
+/* $Id$ */
+
 /** @file
  *
@@ -26 +28 @@
 #include "win32/svchlp.h"
 #endif
-
-#include <VBox/cfgldr.h>
 
 class VirtualBox;
@@ -98 +98 @@
                                      BOOL aActiveChanged = FALSE);
 
-    HRESULT loadSettings (CFGNODE aGlobal);
-    HRESULT saveSettings (CFGNODE aGlobal);
+    HRESULT loadSettings (const settings::Key &aGlobal);
+    HRESULT saveSettings (settings::Key &aGlobal);
 
     HRESULT captureUSBDevice (SessionMachine *aMachine, INPTR GUIDPARAM aId);

trunk/src/VBox/Main/include/MachineImpl.h

@@ +1 @@
+/* $Id$ */
+
 /** @file
  *
@@ -20 +22 @@
 
 #include "VirtualBoxBase.h"
-#include "VirtualBoxXMLUtil.h"
 #include "ProgressImpl.h"
 #include "SnapshotImpl.h"
@@ -38 +39 @@
 
 #include <VBox/types.h>
-#include <VBox/cfgldr.h>
+
 #include <iprt/file.h>
 #include <iprt/thread.h>
+#include <iprt/time.h>
 
 #include <list>
@@ -69 +71 @@
 class ATL_NO_VTABLE Machine :
     public VirtualBoxBaseWithChildrenNEXT,
-    public VirtualBoxXMLUtil,
     public VirtualBoxSupportErrorInfoImpl <Machine, IMachine>,
     public VirtualBoxSupportTranslation <Machine>,
@@ -141 +142 @@
 
         MachineState_T mMachineState;
-        LONG64 mLastStateChange;
+        RTTIMESPEC mLastStateChange;
 
         uint32_t mMachineStateDeps;
@@ -557 +558 @@
     virtual HRESULT onSharedFolderChange() { return S_OK; }
 
-    HRESULT saveRegistryEntry (CFGNODE aEntryNode);
+    HRESULT saveRegistryEntry (settings::Key &aEntryNode);
 
     int calculateFullPath (const char *aPath, Utf8Str &aResult);
@@ -613 +614 @@
 
     HRESULT loadSettings (bool aRegistered);
-    HRESULT loadSnapshot (CFGNODE aNode, const Guid &aCurSnapshotId,
+    HRESULT loadSnapshot (const settings::Key &aNode, const Guid &aCurSnapshotId,
                           Snapshot *aParentSnapshot);
-    HRESULT loadHardware (CFGNODE aNode);
-    HRESULT loadHardDisks (CFGNODE aNode, bool aRegistered,
+    HRESULT loadHardware (const settings::Key &aNode);
+    HRESULT loadHardDisks (const settings::Key &aNode, bool aRegistered,
                            const Guid *aSnapshotId = NULL);
 
-    HRESULT openConfigLoader (CFGHANDLE *aLoader, bool aIsNew = false);
-    HRESULT closeConfigLoader (CFGHANDLE aLoader, bool aSaveBeforeClose);
-
-    HRESULT findSnapshotNode (Snapshot *aSnapshot, CFGNODE aMachineNode,
-                              CFGNODE *aSnapshotsNode, CFGNODE *aSnapshotNode);
+    HRESULT findSnapshotNode (Snapshot *aSnapshot, settings::Key &aMachineNode,
+                              settings::Key *aSnapshotsNode,
+                              settings::Key *aSnapshotNode);
 
     HRESULT findSnapshot (const Guid &aId, ComObjPtr <Snapshot> &aSnapshot,
@@ -655 +654 @@
 
     HRESULT saveSnapshotSettings (Snapshot *aSnapshot, int aOpFlags);
-    HRESULT saveSnapshotSettingsWorker (CFGNODE aMachineNode,
+    HRESULT saveSnapshotSettingsWorker (settings::Key &aMachineNode,
                                         Snapshot *aSnapshot, int aOpFlags);
 
-    HRESULT saveSnapshot (CFGNODE aNode, Snapshot *aSnapshot, bool aAttrsOnly);
-    HRESULT saveHardware (CFGNODE aNode);
-    HRESULT saveHardDisks (CFGNODE aNode);
+    HRESULT saveSnapshot (settings::Key &aNode, Snapshot *aSnapshot, bool aAttrsOnly);
+    HRESULT saveHardware (settings::Key &aNode);
+    HRESULT saveHardDisks (settings::Key &aNode);
 
     HRESULT saveStateSettings (int aFlags);
@@ -919 +918 @@
     HRESULT init (SessionMachine *aSessionMachine,
                   INPTR GUIDPARAM aSnapshotId, INPTR BSTR aStateFilePath);
-    HRESULT init (Machine *aMachine, CFGNODE aHWNode, CFGNODE aHDAsNode,
+    HRESULT init (Machine *aMachine,
+                  const settings::Key &aHWNode, const settings::Key &aHDAsNode,
                   INPTR GUIDPARAM aSnapshotId, INPTR BSTR aStateFilePath);
     void uninit();

trunk/src/VBox/Main/include/NetworkAdapterImpl.h

@@ +1 @@
+/* $Id$ */
+
 /** @file
  *
@@ -146 +148 @@
     // public methods only for internal purposes
 
+    HRESULT loadSettings (const settings::Key &aAdapterNode);
+    HRESULT saveSettings (settings::Key &aAdapterNode);
+
     bool isModified() { AutoLock alock (this); return mData.isBackedUp(); }
     bool isReallyModified() { AutoLock alock (this); return mData.hasActualChanges(); }

trunk/src/VBox/Main/include/ParallelPortImpl.h

@@ -1 +1 @@
 /* $Id$ */
+
 /** @file
  * VirtualBox COM class implementation.
@@ -20 +21 @@
 
 #include "VirtualBoxBase.h"
-
-#include <VBox/cfgldr.h>
 
 class Machine;
@@ -95 +94 @@
 
     // public methods only for internal purposes
+
+    HRESULT loadSettings (const settings::Key &aPortNode);
+    HRESULT saveSettings (settings::Key &aPortNode);
+
     bool isModified() { AutoLock alock (this); return mData.isBackedUp(); }
     bool isReallyModified() { AutoLock alock (this); return mData.hasActualChanges(); }
@@ -103 +106 @@
     // public methods for internal purposes only
     // (ensure there is a caller and a read lock before calling them!)
-
-    HRESULT loadSettings (CFGNODE aMachine, ULONG aSlot);
-    HRESULT saveSettings (CFGNODE aMachine);
 
     // for VirtualBoxSupportErrorInfoImpl

trunk/src/VBox/Main/include/SerialPortImpl.h

@@ +1 @@
+/* $Id$ */
+
 /** @file
  *
@@ -20 +22 @@
 
 #include "VirtualBoxBase.h"
-
-#include <VBox/cfgldr.h>
 
 class Machine;
@@ -105 +105 @@
 
     // public methods only for internal purposes
+
+    HRESULT loadSettings (const settings::Key &aPortNode);
+    HRESULT saveSettings (settings::Key &aPortNode);
+
     bool isModified() { AutoLock alock (this); return mData.isBackedUp(); }
     bool isReallyModified() { AutoLock alock (this); return mData.hasActualChanges(); }
@@ -113 +117 @@
     // public methods for internal purposes only
     // (ensure there is a caller and a read lock before calling them!)
-
-    HRESULT loadSettings (CFGNODE aMachine, ULONG aSlot);
-    HRESULT saveSettings (CFGNODE aMachine);
 
     // for VirtualBoxSupportErrorInfoImpl

trunk/src/VBox/Main/include/SnapshotImpl.h

@@ -22 +22 @@
 #include "Collection.h"
 
+#include <iprt/time.h>
+
 #include <list>
 
@@ -42 +44 @@
         Bstr mName;
         Bstr mDescription;
-        LONG64 mTimeStamp;
+        RTTIMESPEC mTimeStamp;
         ComObjPtr <SnapshotMachine> mMachine;
     };
@@ -65 +67 @@
     // public initializer/uninitializer only for internal purposes
     HRESULT init (const Guid &aId, INPTR BSTR aName, INPTR BSTR aDescription,
-                  LONG64 aTimeStamp, SnapshotMachine *aMachine,
+                  RTTIMESPEC aTimeStamp, SnapshotMachine *aMachine,
                   Snapshot *aParent);
     void uninit();

trunk/src/VBox/Main/include/SystemPropertiesImpl.h

@@ +1 @@
+/* $Id$ */
+
 /** @file
  *
@@ -20 +22 @@
 
 #include "VirtualBoxBase.h"
-
-#include <VBox/cfgldr.h>
 
 class VirtualBox;
@@ -77 +77 @@
     // public methods only for internal purposes
 
-    HRESULT loadSettings (CFGNODE aGlobal);
-    HRESULT saveSettings (CFGNODE aGlobal);
+    HRESULT loadSettings (const settings::Key &aGlobal);
+    HRESULT saveSettings (settings::Key &aGlobal);
 
     /** Default VDI path (as is, not full). Not thread safe (use object lock). */

trunk/src/VBox/Main/include/USBControllerImpl.h

@@ +1 @@
+/* $Id$ */
+
 /** @file
  *
@@ -21 +23 @@
 #include "VirtualBoxBase.h"
 #include "USBDeviceFilterImpl.h"
-
-#include <VBox/cfgldr.h>
 
 #include <list>
@@ -102 +102 @@
     // public methods only for internal purposes
 
-    HRESULT loadSettings (CFGNODE aMachine);
-    HRESULT saveSettings (CFGNODE aMachine);
+    HRESULT loadSettings (const settings::Key &aMachineNode);
+    HRESULT saveSettings (settings::Key &aMachineNode);
 
     bool isModified();

trunk/src/VBox/Main/include/VRDPServerImpl.h

@@ +1 @@
+/* $Id$ */
+
 /** @file
  *
@@ -22 +24 @@
 
 #include <VBox/VRDPAuth.h>
-#include <VBox/cfgldr.h>
 
 class Machine;
@@ -97 +98 @@
     // public methods only for internal purposes
 
-    HRESULT loadSettings (CFGNODE aNode);
-    HRESULT saveSettings (CFGNODE aNode);
+    HRESULT loadSettings (const settings::Key &aMachineNode);
+    HRESULT saveSettings (settings::Key &aMachineNode);
 
     bool isModified() { AutoLock alock (this); return mData.isBackedUp(); }

trunk/src/VBox/Main/include/VirtualBoxBase.h

@@ -25 +25 @@
 
 #include "VBox/com/VirtualBox.h"
+
+#include <VBox/settings.h>
 
 #include "AutoLock.h"
@@ -121 +123 @@
 
 /**
- *  A special version of the Assert macro to be used within VirtualBoxBase
+ *  Special version of the Assert macro to be used within VirtualBoxBase
  *  subclasses that also inherit the VirtualBoxSupportErrorInfoImpl template.
  *
@@ -145 +147 @@
 
 /**
- *  A special version of the AssertMsg macro to be used within VirtualBoxBase
+ *  Special version of the AssertMsg macro to be used within VirtualBoxBase
  *  subclasses that also inherit the VirtualBoxSupportErrorInfoImpl template.
  *
@@ -167 +169 @@
 
 /**
- *  A special version of the AssertRC macro to be used within VirtualBoxBase
+ *  Special version of the AssertRC macro to be used within VirtualBoxBase
  *  subclasses that also inherit the VirtualBoxSupportErrorInfoImpl template.
  *
@@ -181 +183 @@
 
 /**
- *  A special version of the AssertMsgRC macro to be used within VirtualBoxBase
+ *  Special version of the AssertMsgRC macro to be used within VirtualBoxBase
  *  subclasses that also inherit the VirtualBoxSupportErrorInfoImpl template.
  *
@@ -197 +199 @@
 
 /**
- *  A special version of the AssertFailed macro to be used within VirtualBoxBase
+ *  Special version of the AssertFailed macro to be used within VirtualBoxBase
  *  subclasses that also inherit the VirtualBoxSupportErrorInfoImpl template.
  *
@@ -214 +216 @@
 
 /**
- *  A special version of the AssertMsgFailed macro to be used within VirtualBoxBase
+ *  Special version of the AssertMsgFailed macro to be used within VirtualBoxBase
  *  subclasses that also inherit the VirtualBoxSupportErrorInfoImpl template.
  *
@@ -234 +236 @@
 
 /**
- *  A special version of the AssertComRC macro to be used within VirtualBoxBase
+ *  Special version of the ComAssertMsgFailed macro that additionally takes
+ *  line number, file and function arguments to inject an assertion position
+ *  that differs from the position where this macro is instantiated.
+ *
+ *  @param   a                  printf argument list (in parenthesis).
+ *  @param   file, line, func   Line number (int), file and function (const char *).
+ */
+#if defined (DEBUG)
+#define ComAssertMsgFailedPos(a, file, line, func)              \
+    do {                                                        \
+        AssertMsg1 ((const char *) 0, line, file, func);        \
+        AssertMsg2 a;                                           \
+        AssertBreakpoint();                                     \
+    } while (0)
+#else
+#define ComAssertMsgFailedPos(a, file, line, func)              \
+    do {                                                        \
+        setError (E_FAIL,                                       \
+                  "Assertion failed at '%s' (%d) in %s.\n"      \
+                  "%s.\n"                                       \
+                  "Please contact the product vendor!",         \
+                  file, line, func, Utf8StrFmt a .raw());       \
+    } while (0)
+#endif
+
+/**
+ *  Special version of the AssertComRC macro to be used within VirtualBoxBase
  *  subclasses that also inherit the VirtualBoxSupportErrorInfoImpl template.
  *
@@ -299 +327 @@
     if (1)  { ComAssertComRC (rc); if (!SUCCEEDED (rc)) { break; } } else do {} while (0)
 
+
+/** Special version of ComAssert that evaulates eval and throws it if expr fails */
+#define ComAssertThrow(expr, eval)                \
+    if (1) { ComAssert (expr); if (!(expr)) { throw (eval); } } else do {} while (0)
+/** Special version of ComAssertMsg that evaulates eval and throws it if expr fails */
+#define ComAssertMsgThrow(expr, a, eval)          \
+    if (1)  { ComAssertMsg (expr, a); if (!(expr)) { throw (eval); } } else do {} while (0)
+/** Special version of ComAssertRC that evaulates eval and throws it if vrc does not succeed */
+#define ComAssertRCThrow(vrc, eval)               \
+    if (1)  { ComAssertRC (vrc); if (!VBOX_SUCCESS (vrc)) { throw (eval); } } else do {} while (0)
+/** Special version of ComAssertMsgRC that evaulates eval and throws it if vrc does not succeed */
+#define ComAssertMsgRCThrow(vrc, msg, eval)       \
+    if (1)  { ComAssertMsgRC (vrc, msg); if (!VBOX_SUCCESS (vrc)) { throw (eval); } } else do {} while (0)
+/** Special version of ComAssertFailed that evaulates eval and throws it */
+#define ComAssertFailedThrow(eval)                \
+    if (1)  { ComAssertFailed(); { throw (eval); } } else do {} while (0)
+/** Special version of ComAssertMsgFailed that evaulates eval and throws it */
+#define ComAssertMsgFailedThrow(msg, eval)        \
+    if (1)  { ComAssertMsgFailed (msg); { throw (eval); } } else do {} while (0)
+/** Special version of ComAssertComRC that evaulates eval and throws it if rc does not succeed */
+#define ComAssertComRCThrow(rc, eval)             \
+    if (1)  { ComAssertComRC (rc); if (!SUCCEEDED (rc)) { throw (eval); } } else do {} while (0)
+/** Special version of ComAssertComRC that just throws rc if rc does not succeed */
+#define ComAssertComRCThrowRC(rc)                 \
+    if (1)  { ComAssertComRC (rc); if (!SUCCEEDED (rc)) { throw rc; } } else do {} while (0)
+
+
 /// @todo (dmik) remove after we switch to VirtualBoxBaseNEXT completely
 /**
@@ -1924 +1979 @@
 };
 
+#if defined VBOX_MAIN_SETTINGS_ADDONS
+
+/** 
+ * Settinsg API additions.
+ */
+namespace settings
+{
+
+/// @todo once string data in Bstr and Utf8Str is auto_ref_ptr, enable the
+/// code below
+
+#if 0
+
+/** Specialization of FromString for Bstr. */
+template<> com::Bstr FromString <com::Bstr> (const char *aValue);
+
+#endif
+
+/** Specialization of ToString for Bstr. */
+template<> stdx::char_auto_ptr
+ToString <com::Bstr> (const com::Bstr &aValue, unsigned int aExtra);
+
+/** Specialization of FromString for Guid. */
+template<> com::Guid FromString <com::Guid> (const char *aValue);
+
+/** Specialization of ToString for Guid. */
+template<> stdx::char_auto_ptr
+ToString <com::Guid> (const com::Guid &aValue, unsigned int aExtra);
+
+} /* namespace settings */
+
+#endif /* VBOX_MAIN_SETTINGS_ADDONS */
+
 #endif // ____H_VIRTUALBOXBASEIMPL

trunk/src/VBox/Main/include/VirtualBoxImpl.h

@@ +1 @@
+/* $Id$ */
+
 /** @file
  *
@@ -20 +22 @@
 
 #include "VirtualBoxBase.h"
-#include "VirtualBoxXMLUtil.h"
 
 #include "VBox/com/EventQueue.h"
-
-#include <VBox/cfgldr.h>
 
 #include <list>
@@ -60 +59 @@
 class ATL_NO_VTABLE VirtualBox :
     public VirtualBoxBaseWithChildrenNEXT,
-    public VirtualBoxXMLUtil,
     public VirtualBoxSupportErrorInfoImpl <VirtualBox, IVirtualBox>,
     public VirtualBoxSupportTranslation <VirtualBox>,
@@ -253 +251 @@
     HRESULT unregisterDiffHardDisk (HardDisk *aHardDisk);
 
-    HRESULT saveSettings() { return saveConfig(); }
+    HRESULT saveSettings();
     HRESULT updateSettings (const char *aOldPath, const char *aNewPath);
 
     const Bstr &settingsFileName() { return mData.mCfgFile.mName; }
+
+    class SettingsInputResolver : public settings::XmlTreeBackend::InputResolver
+    {
+    public:
+
+        settings::Input *resolveEntity (const char *aURI, const char *aID);
+    };
+
+    static HRESULT loadSettingsTree (settings::XmlTreeBackend &aTree,
+                                     settings::File &aFile,
+                                     bool aValidate,
+                                     bool aCatchLoadErrors,
+                                     bool aAddDefaults);
+
+    /** 
+     * Shortcut to loadSettingsTree (aTree, aFile, true, true, true).
+     *
+     * Used when the settings file is to be loaded for the first time for the
+     * given object in order to recreate it from the stored settings.
+     */
+    static HRESULT loadSettingsTree_FirstTime (settings::XmlTreeBackend &aTree,
+                                               settings::File &aFile)
+    {
+        return loadSettingsTree (aTree, aFile, true, true, true);
+    }
+
+    /** 
+     * Shortcut to loadSettingsTree (aTree, aFile, true, false, true).
+     *
+     * Used when the settings file is loaded again (after it has been fully
+     * checked and validated by #loadSettingsTree_FirstTime()) in order to
+     * look at settings that don't have any representation within object's
+     * data fields.
+     */
+    static HRESULT loadSettingsTree_Again (settings::XmlTreeBackend &aTree,
+                                           settings::File &aFile)
+    {
+        return loadSettingsTree (aTree, aFile, true, false, true);
+    }
+
+    /** 
+     * Shortcut to loadSettingsTree (aTree, aFile, true, false, false).
+     *
+     * Used when the settings file is loaded again (after it has been fully
+     * checked and validated by #loadSettingsTree_FirstTime()) in order to
+     * update some settings and then save them back.
+     */
+    static HRESULT loadSettingsTree_ForUpdate (settings::XmlTreeBackend &aTree,
+                                               settings::File &aFile)
+    {
+        return loadSettingsTree (aTree, aFile, true, false, false);
+    }
+
+    static HRESULT saveSettingsTree (settings::TreeBackend &aTree,
+                                     settings::File &aFile);
+
+    static HRESULT handleUnexpectedExceptions (RT_SRC_POS_DECL);
 
     /* for VirtualBoxSupportErrorInfoImpl */
@@ -290 +345 @@
                                     const Guid *aId, const BSTR aFilePathFull);
 
-    HRESULT loadMachines (CFGNODE aGlobal);
-    HRESULT loadDisks (CFGNODE aGlobal);
-    HRESULT loadHardDisks (CFGNODE aNode);
-
-    HRESULT saveConfig();
-    HRESULT saveHardDisks (CFGNODE aNode);
+    HRESULT loadMachines (const settings::Key &aGlobal);
+    HRESULT loadDisks (const settings::Key &aGlobal);
+    HRESULT loadHardDisks (const settings::Key &aNode);
+
+    HRESULT saveHardDisks (settings::Key &aNode);
 
     HRESULT registerMachine (Machine *aMachine);

trunk/src/VBox/Main/include/VirtualBoxXMLUtil.h

@@ +1 @@
+/* $Id$ */
+
 /** @file
  *
- * VirtualBox XML utility class declaration
+ * VirtualBox XML/Settings API utility declarations
  */
 
@@ -18 +20 @@
 #ifndef ____H_VIRTUALBOXXMLUTIL
 #define ____H_VIRTUALBOXXMLUTIL
-
-// for BSTR referred from VBox/cfgldr.h
-#include "VBox/com/defs.h"
-
-#include <VBox/cdefs.h>
-#include <VBox/cfgldr.h>
-#include <iprt/file.h>
 
 /** VirtualBox XML settings namespace */
@@ -59 +54 @@
 #define VBOX_XML_SCHEMA_COMMON  "VirtualBox-settings-" VBOX_XML_PLATFORM_COMMON ".xsd"
 
-class VirtualBoxXMLUtil
-{
-protected:
-
-    static DECLCALLBACK(int) cfgLdrEntityResolver (const char *pcszPublicId,
-                                                   const char *pcszSystemId,
-                                                   const char *pcszBaseURI,
-                                                   PCFGLDRENTITY pEntity);
-
-    /** VirtualBox XML settings "namespace schema" pair */
-    static const char *XmlSchemaNS;
-};
-
-
-#endif // ____H_VIRTUALBOXXMLUTIL
-
+#endif /* ____H_VIRTUALBOXXMLUTIL */

trunk/src/VBox/Main/xml/VirtualBox-settings-common.xsd

@@ -303 +303 @@
   <xsd:attribute name="port" type="xsd:token"/>
   <xsd:attribute name="remote" type="xsd:token"/>
-  <xsd:attribute name="maskedInterfaces" type="xsd:unsignedInt"/>
+  <xsd:attribute name="maskedInterfaces" type="xsd:unsignedInt" default="0"/>
 </xsd:complexType>
 
@@ -437 +437 @@
 
 <xsd:complexType name="TRemoteDisplay">
-  <xsd:attribute name="enabled" type="xsd:boolean"/>
+  <xsd:attribute name="enabled" type="xsd:boolean" use="required"/>
   <xsd:attribute name="port" type="xsd:unsignedInt" default="0"/>
   <xsd:attribute name="netAddress" type="xsd:token" default=""/>
@@ -644 +644 @@
 <xsd:complexType name="THardware">
   <xsd:all>
-    <xsd:element name="CPU" type="TCPU" minOccurs = "0"/>
+    <xsd:element name="CPU" type="TCPU" minOccurs="0"/>
     <xsd:element name="Memory" type="TMemory"/>
     <xsd:element name="Boot" type="TBoot">
@@ -708 +708 @@
   <!--- @todo (dmik) make lastStateChange required on next format change! -->
   <xsd:attribute name="lastStateChange" type="TPresentDateTimeUTC"/>
-  <xsd:attribute name="aborted" type="xsd:boolean"/>
+  <xsd:attribute name="aborted" type="xsd:boolean" default="false"/>
   <xsd:attribute name="currentStateModified" type="xsd:boolean" default="true"/>
 </xsd:complexType>

trunk/src/VBox/Main/xml/VirtualBox-settings-freebsd.xsd

@@ -86 +86 @@
 
 <xsd:complexType name="TAudioAdapter">
-  <xsd:attribute name="enabled" type="xsd:boolean"/>
+  <xsd:attribute name="enabled" type="xsd:boolean" use="required"/>
   <xsd:attribute name="driver" use="required">
     <!--- @todo (dmik) capitalize enum values on next format change! -->

trunk/src/VBox/Main/xml/VirtualBox-settings-linux.xsd

@@ -86 +86 @@
 
 <xsd:complexType name="TAudioAdapter">
-  <xsd:attribute name="enabled" type="xsd:boolean"/>
+  <xsd:attribute name="enabled" type="xsd:boolean" use="required"/>
   <xsd:attribute name="driver" use="required">
     <!--- @todo (dmik) capitalize enum values on next format change! -->

trunk/src/VBox/Main/xml/VirtualBox-settings-macosx.xsd

@@ -86 +86 @@
 
 <xsd:complexType name="TAudioAdapter">
-  <xsd:attribute name="enabled" type="xsd:boolean"/>
+  <xsd:attribute name="enabled" type="xsd:boolean" use="required"/>
   <xsd:attribute name="driver" use="required">
     <!--- @todo (dmik) capitalize enum values on next format change! -->

trunk/src/VBox/Main/xml/VirtualBox-settings-os2.xsd

@@ -86 +86 @@
 
 <xsd:complexType name="TAudioAdapter">
-  <xsd:attribute name="enabled" type="xsd:boolean"/>
+  <xsd:attribute name="enabled" type="xsd:boolean" use="required"/>
   <xsd:attribute name="driver" use="required">
     <!--- @todo (dmik) capitalize enum values on next format change! -->

trunk/src/VBox/Main/xml/VirtualBox-settings-solaris.xsd

@@ -86 +86 @@
 
 <xsd:complexType name="TAudioAdapter">
-  <xsd:attribute name="enabled" type="xsd:boolean"/>
+  <xsd:attribute name="enabled" type="xsd:boolean" use="required"/>
   <xsd:attribute name="driver" use="required">
     <!--- @todo (dmik) capitalize enum values on next format change! -->

trunk/src/VBox/Main/xml/VirtualBox-settings-windows.xsd

@@ -84 +84 @@
 
 <xsd:complexType name="TAudioAdapter">
-  <xsd:attribute name="enabled" type="xsd:boolean"/>
+  <xsd:attribute name="enabled" type="xsd:boolean" use="required"/>
   <xsd:attribute name="driver" use="required">
     <!--- @todo (dmik) capitalize enum values on next format change! -->