VirtualBox

Changeset 30764 in vbox


Ignore:
Timestamp:
Jul 9, 2010 2:12:12 PM (15 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
63552
Message:

back out r63543, r63544 until windows build problems can be solved properly

Location:
trunk
Files:
51 edited
1 copied

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/settings.h

    r30760 r30764  
    841841public:
    842842    com::Guid               uuid;
    843 
    844     com::Utf8Str            strStateFile;
    845     com::Guid               uuidCurrentSnapshot;
    846 
    847843    com::Utf8Str            strName;
    848844    bool                    fNameSync;
    849845    com::Utf8Str            strDescription;
    850846    com::Utf8Str            strOsType;
     847    com::Utf8Str            strStateFile;
     848    com::Guid               uuidCurrentSnapshot;
    851849    com::Utf8Str            strSnapshotFolder;
    852850    bool                    fTeleporterEnabled;

  • trunk/src/VBox/Frontends/VBoxBFE/Makefile.kmk

    r30760 r30764  
    2424#
    2525VBOXBFE_MAIN_CPP = MouseImpl.cpp
    26 VBOXBFE_MAIN_H   = MouseImpl.h
     26VBOXBFE_MAIN_H   = MouseImpl.h ConsoleEvents.h
    2727
    2828#

  • trunk/src/VBox/Main/ApplianceImpl.cpp

    r30760 r30764  
    2020#include <iprt/cpp/utils.h>
    2121
     22#include <VBox/com/array.h>
     23
     24#include "ApplianceImpl.h"
    2225#include "VFSExplorerImpl.h"
    2326#include "VirtualBoxImpl.h"
    … …  
    2629#include "MachineImpl.h"
    2730
    28 #include "ApplianceImplPrivate.h"
    29 
    3031#include "AutoCaller.h"
    3132#include "Logging.h"
    3233
    33 #include "VBox/settings.h"
    34 
    35 #include <VBox/com/array.h>
     34#include "ApplianceImplPrivate.h"
    3635
    3736using namespace std;

  • trunk/src/VBox/Main/ApplianceImplExport.cpp

    r30760 r30764  
    1717 */
    1818
    19 #include <iprt/file.h>
    2019#include <iprt/path.h>
    2120#include <iprt/dir.h>
    … …  
    2423#include <iprt/manifest.h>
    2524
    26 #include "AudioAdapterImpl.h"
     25#include <VBox/version.h>
     26
     27#include "ApplianceImpl.h"
    2728#include "VirtualBoxImpl.h"
     29
    2830#include "ProgressImpl.h"
    29 #include "MachineImplPrivate.h"
    30 #include "MediumAttachmentImpl.h"
    31 
    32 #include "ApplianceImplPrivate.h"
     31#include "MachineImpl.h"
    3332
    3433#include "AutoCaller.h"
    3534#include "Logging.h"
    3635
    37 #include <VBox/version.h>
    38 #include <VBox/com/array.h>
     36#include "ApplianceImplPrivate.h"
    3937
    4038using namespace std;
    … …  
    277275//     <const name="CDROM" value="19" />
    278276
    279         MediumAttachmentsList::iterator itA;
     277        MediaData::AttachmentList::iterator itA;
    280278        for (itA = mMediaData->mAttachments.begin();
    281279             itA != mMediaData->mAttachments.end();

  • trunk/src/VBox/Main/ApplianceImplImport.cpp

    r30763 r30764  
    2424#include <iprt/manifest.h>
    2525
     26#include <VBox/com/array.h>
     27
     28#include "ApplianceImpl.h"
    2629#include "VirtualBoxImpl.h"
    2730#include "GuestOSTypeImpl.h"
    … …  
    2932#include "MachineImpl.h"
    3033
    31 #include "ApplianceImplPrivate.h"
    32 
    3334#include "AutoCaller.h"
    3435#include "Logging.h"
     36
     37#include "ApplianceImplPrivate.h"
    3538
    3639#include <VBox/param.h>
    3740#include <VBox/version.h>
    3841#include <VBox/settings.h>
    39 
    40 #include <VBox/com/array.h>
    4142
    4243using namespace std;

  • trunk/src/VBox/Main/ConsoleVRDPServer.cpp

    r30760 r30764  
    1616 */
    1717
    18 #include "RemoteUSBBackend.h"
    1918#include "ConsoleVRDPServer.h"
    2019#include "ConsoleImpl.h"

  • trunk/src/VBox/Main/DHCPServerImpl.cpp

    r30760 r30764  
    1818 */
    1919
     20#include "DHCPServerRunner.h"
    2021#include "DHCPServerImpl.h"
    2122#include "AutoCaller.h"

  • trunk/src/VBox/Main/HostImpl.cpp

    r30760 r30764  
    140140#include <VBox/sup.h>
    141141
    142 #include <VBox/com/array.h>
    143142#include "VBox/com/MultiResult.h"
    144143

  • trunk/src/VBox/Main/HostPower.cpp

    r30760 r30764  
    2929
    3030#include <iprt/mem.h>
    31 
    32 #ifdef VBOX_WITH_RESOURCE_USAGE_API
    33  #include "Performance.h"
    34  #include "PerformanceImpl.h"
    35 #endif /* VBOX_WITH_RESOURCE_USAGE_API */
    3631
    3732HostPowerService::HostPowerService (VirtualBox *aVirtualBox)

  • trunk/src/VBox/Main/MachineImpl.cpp

    r30760 r30764  
    3434#include "Logging.h"
    3535#include "VirtualBoxImpl.h"
    36 #include "MachineImplPrivate.h"
    37 
    38 #include "VirtualBoxErrorInfoImpl.h"
    39 
    40 #include "AudioAdapterImpl.h"
    41 #include "BIOSSettingsImpl.h"
    42 #include "GuestImpl.h"
    43 #include "GuestOSTypeImpl.h"
    44 #include "HostImpl.h"
     36#include "MachineImpl.h"
     37#include "ProgressImpl.h"
     38#include "ProgressProxyImpl.h"
    4539#include "MediumAttachmentImpl.h"
    4640#include "MediumImpl.h"
    4741#include "MediumLock.h"
    48 #include "NetworkAdapterImpl.h"
    49 #include "ParallelPortImpl.h"
    50 #include "ProgressProxyImpl.h"
    5142#include "USBControllerImpl.h"
    52 #include "SerialPortImpl.h"
     43#include "HostImpl.h"
    5344#include "SharedFolderImpl.h"
     45#include "GuestOSTypeImpl.h"
     46#include "VirtualBoxErrorInfoImpl.h"
     47#include "GuestImpl.h"
    5448#include "StorageControllerImpl.h"
    55 #include "VRDPServerImpl.h"
    5649
    5750#ifdef VBOX_WITH_USB
    … …  
    5952#endif
    6053
    61 #ifdef VBOX_WITH_RESOURCE_USAGE_API
    62 # include "Performance.h"
    63 # include "PerformanceImpl.h"
    64 #endif /* VBOX_WITH_RESOURCE_USAGE_API */
    65 
    6654#include "AutoCaller.h"
    6755#include "Performance.h"
    6856
    6957#include <iprt/asm.h>
    70 #include <iprt/file.h>
    7158#include <iprt/path.h>
    7259#include <iprt/dir.h>
    … …  
    29232910        if (aType == DeviceType_HardDisk && mMediaData.isBackedUp())
    29242911        {
    2925             const MediumAttachmentsList &oldAtts = mMediaData.backedUpData()->mAttachments;
     2912            const MediaData::AttachmentList &oldAtts = mMediaData.backedUpData()->mAttachments;
    29262913
    29272914            /* check if the medium was attached to the VM before we started
    … …  
    29632950            if (mMediaData.isBackedUp())
    29642951            {
    2965                 const MediumAttachmentsList &oldAtts = mMediaData.backedUpData()->mAttachments;
    2966 
    2967                 MediumAttachmentsList::const_iterator foundIt = oldAtts.end();
     2952                const MediaData::AttachmentList &oldAtts = mMediaData.backedUpData()->mAttachments;
     2953
     2954                MediaData::AttachmentList::const_iterator foundIt = oldAtts.end();
    29682955                uint32_t foundLevel = 0;
    29692956
    2970                 for (MediumAttachmentsList::const_iterator it = oldAtts.begin();
     2957                for (MediaData::AttachmentList::const_iterator it = oldAtts.begin();
    29712958                     it != oldAtts.end();
    29722959                     ++it)
    … …  
    30383025                AutoReadLock snapLock(snap COMMA_LOCKVAL_SRC_POS);
    30393026
    3040                 const MediumAttachmentsList &snapAtts = snap->getSnapshotMachine()->mMediaData->mAttachments;
    3041 
    3042                 MediumAttachmentsList::const_iterator foundIt = snapAtts.end();
     3027                const MediaData::AttachmentList &snapAtts = snap->getSnapshotMachine()->mMediaData->mAttachments;
     3028
     3029                MediaData::AttachmentList::const_iterator foundIt = snapAtts.end();
    30433030                uint32_t foundLevel = 0;
    30443031
    3045                 for (MediumAttachmentsList::const_iterator it = snapAtts.begin();
     3032                for (MediaData::AttachmentList::const_iterator it = snapAtts.begin();
    30463033                     it != snapAtts.end();
    30473034                     ++it)
    … …  
    43874374                                                       ComSafeArrayOut(IMediumAttachment*, aAttachments))
    43884375{
    4389     MediumAttachmentsList atts;
     4376    MediaData::AttachmentList atts;
    43904377
    43914378    HRESULT rc = getMediumAttachmentsOfController(aName, atts);
    … …  
    45534540    /* We can remove the controller only if there is no device attached. */
    45544541    /* check if the device slot is already busy */
    4555     for (MediumAttachmentsList::const_iterator it = mMediaData->mAttachments.begin();
     4542    for (MediaData::AttachmentList::const_iterator it = mMediaData->mAttachments.begin();
    45564543         it != mMediaData->mAttachments.end();
    45574544         ++it)
    … …  
    50515038
    50525039/**
    5053  * Returns true if the machine is registered.
    5054  *
    5055  * @note This method doesn't check this object's readiness. Intended to be
    5056  * used by ready Machine children (whose readiness is bound to the parent's
    5057  * one) or after doing addCaller() manually.
    5058  */
    5059 bool Machine::isRegistered() const
    5060 {
    5061     return !!mData->mRegistered;
    5062 }
    5063 
    5064 /**
    5065  * Returns this machine ID.
    5066  *
    5067  * @note This method doesn't check this object's readiness. Intended to be
    5068  * used by ready Machine children (whose readiness is bound to the parent's
    5069  * one) or after adding a caller manually.
    5070  */
    5071 const Guid& Machine::getId() const
    5072 {
    5073     return mData->mUuid;
    5074 }
    5075 
    5076 /**
    5077  * Returns this machine's full settings file path.
    5078  *
    5079  * @note This method doesn't lock this object or check its readiness.
    5080  * Intended to be used only after doing addCaller() manually and locking it
    5081  * for reading.
    5082  */
    5083 const Utf8Str& Machine::getSettingsFileFull() const
    5084 {
    5085     return mData->m_strConfigFileFull;
    5086 }
    5087 
    5088 /**
    5089  * Returns this machine name.
    5090  *
    5091  * @note This method doesn't lock this object or check its readiness.
    5092  * Intended to be used only after doing addCaller() manually and locking it
    5093  * for reading.
    5094  */
    5095 const Bstr& Machine::getName() const
    5096 {
    5097     return mUserData->mName;
    5098 }
    5099 
    5100 
    5101 /**
    51025040 * Adds the given IsModified_* flag to the dirty flags of the machine.
    5103  *
    51045041 * This must be called either during loadSettings or under the machine write lock.
    5105  *
    51065042 * @param fl
    51075043 */
    … …  
    57735709}
    57745710
    5775 HRESULT Machine::getDirectControl(ComPtr<IInternalSessionControl> &directControl)
    5776 {
    5777     directControl = mData->mSession.mDirectControl;
    5778 
    5779     if (directControl.isNull())
    5780         return E_ACCESSDENIED;
    5781 
    5782     return S_OK;
    5783 }
    5784 
    57855711/**
    57865712 * Returns @c true if the given machine has an open direct session and returns
    … …  
    64346360       )
    64356361    {
    6436         for (MediumAttachmentsList::const_iterator it = mMediaData->mAttachments.begin();
     6362        for (MediaData::AttachmentList::const_iterator it = mMediaData->mAttachments.begin();
    64376363             it != mMediaData->mAttachments.end();
    64386364             ++it)
    … …  
    73817307
    73827308HRESULT Machine::getMediumAttachmentsOfController(CBSTR aName,
    7383                                                   MediumAttachmentsList &atts)
     7309                                                  MediaData::AttachmentList &atts)
    73847310{
    73857311    AutoCaller autoCaller(this);
    … …  
    73887314    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    73897315
    7390     for (MediumAttachmentsList::iterator it = mMediaData->mAttachments.begin();
     7316    for (MediaData::AttachmentList::iterator it = mMediaData->mAttachments.begin();
    73917317         it != mMediaData->mAttachments.end();
    73927318         ++it)
    … …  
    81448070                                    settings::StorageController &data)
    81458071{
    8146     MediumAttachmentsList atts;
     8072    MediaData::AttachmentList atts;
    81478073
    81488074    HRESULT rc = getMediumAttachmentsOfController(Bstr(aStorageController->getName()), atts);
    … …  
    81508076
    81518077    data.llAttachedDevices.clear();
    8152     for (MediumAttachmentsList::const_iterator it = atts.begin();
     8078    for (MediaData::AttachmentList::const_iterator it = atts.begin();
    81538079         it != atts.end();
    81548080         ++it)
    … …  
    83108236            /* lock all attached hard disks early to detect "in use"
    83118237             * situations before creating actual diffs */
    8312             for (MediumAttachmentsList::const_iterator it = mMediaData->mAttachments.begin();
     8238            for (MediaData::AttachmentList::const_iterator it = mMediaData->mAttachments.begin();
    83138239                 it != mMediaData->mAttachments.end();
    83148240                 ++it)
    … …  
    83508276        /* remember the current list (note that we don't use backup() since
    83518277         * mMediaData may be already backed up) */
    8352         MediumAttachmentsList atts = mMediaData->mAttachments;
     8278        MediaData::AttachmentList atts = mMediaData->mAttachments;
    83538279
    83548280        /* start from scratch */
    … …  
    83578283        /* go through remembered attachments and create diffs for normal hard
    83588284         * disks and attach them */
    8359         for (MediumAttachmentsList::const_iterator it = atts.begin();
     8285        for (MediaData::AttachmentList::const_iterator it = atts.begin();
    83608286             it != atts.end();
    83618287             ++it)
    … …  
    85018427    HRESULT rc = S_OK;
    85028428
    8503     MediumAttachmentsList implicitAtts;
    8504 
    8505     const MediumAttachmentsList &oldAtts = mMediaData.backedUpData()->mAttachments;
     8429    MediaData::AttachmentList implicitAtts;
     8430
     8431    const MediaData::AttachmentList &oldAtts = mMediaData.backedUpData()->mAttachments;
    85068432
    85078433    /* enumerate new attachments */
    8508     for (MediumAttachmentsList::const_iterator it = mMediaData->mAttachments.begin();
     8434    for (MediaData::AttachmentList::const_iterator it = mMediaData->mAttachments.begin();
    85098435         it != mMediaData->mAttachments.end();
    85108436         ++it)
    … …  
    85598485        alock.leave();
    85608486
    8561         for (MediumAttachmentsList::const_iterator it = implicitAtts.begin();
     8487        for (MediaData::AttachmentList::const_iterator it = implicitAtts.begin();
    85628488             it != implicitAtts.end();
    85638489             ++it)
    … …  
    85948520 * @return
    85958521 */
    8596 MediumAttachment* Machine::findAttachment(const MediumAttachmentsList &ll,
     8522MediumAttachment* Machine::findAttachment(const MediaData::AttachmentList &ll,
    85978523                                          IN_BSTR aControllerName,
    85988524                                          LONG aControllerPort,
    85998525                                          LONG aDevice)
    86008526{
    8601    for (MediumAttachmentsList::const_iterator it = ll.begin();
     8527   for (MediaData::AttachmentList::const_iterator it = ll.begin();
    86028528         it != ll.end();
    86038529         ++it)
    … …  
    86228548 * @return
    86238549 */
    8624 MediumAttachment* Machine::findAttachment(const MediumAttachmentsList &ll,
     8550MediumAttachment* Machine::findAttachment(const MediaData::AttachmentList &ll,
    86258551                                          ComObjPtr<Medium> pMedium)
    86268552{
    8627    for (MediumAttachmentsList::const_iterator it = ll.begin();
     8553   for (MediaData::AttachmentList::const_iterator it = ll.begin();
    86288554         it != ll.end();
    86298555         ++it)
    … …  
    86498575 * @return
    86508576 */
    8651 MediumAttachment* Machine::findAttachment(const MediumAttachmentsList &ll,
     8577MediumAttachment* Machine::findAttachment(const MediaData::AttachmentList &ll,
    86528578                                          Guid &id)
    86538579{
    8654    for (MediumAttachmentsList::const_iterator it = ll.begin();
     8580   for (MediaData::AttachmentList::const_iterator it = ll.begin();
    86558581         it != ll.end();
    86568582         ++it)
    … …  
    86948620        return;
    86958621
    8696     MediumAttachmentsList &oldAtts = mMediaData.backedUpData()->mAttachments;
     8622    MediaData::AttachmentList &oldAtts = mMediaData.backedUpData()->mAttachments;
    86978623    bool fMediaNeedsLocking = false;
    86988624
    86998625    /* enumerate new attachments */
    8700     for (MediumAttachmentsList::const_iterator it = mMediaData->mAttachments.begin();
     8626    for (MediaData::AttachmentList::const_iterator it = mMediaData->mAttachments.begin();
    87018627            it != mMediaData->mAttachments.end();
    87028628            ++it)
    … …  
    87548680        {
    87558681            /* was this medium attached before? */
    8756             for (MediumAttachmentsList::iterator oldIt = oldAtts.begin();
     8682            for (MediaData::AttachmentList::iterator oldIt = oldAtts.begin();
    87578683                    oldIt != oldAtts.end();
    87588684                    ++oldIt)
    … …  
    87738699    /* enumerate remaining old attachments and de-associate from the
    87748700     * current machine state */
    8775     for (MediumAttachmentsList::const_iterator it = oldAtts.begin();
     8701    for (MediaData::AttachmentList::const_iterator it = oldAtts.begin();
    87768702         it != oldAtts.end();
    87778703         ++it)
    … …  
    88528778
    88538779    /* enumerate new attachments */
    8854     for (MediumAttachmentsList::const_iterator it = mMediaData->mAttachments.begin();
     8780    for (MediaData::AttachmentList::const_iterator it = mMediaData->mAttachments.begin();
    88558781            it != mMediaData->mAttachments.end();
    88568782            ++it)
    … …  
    1093510861
    1093610862    /* Collect locking information for all medium objects attached to the VM. */
    10937     for (MediumAttachmentsList::const_iterator it = mMediaData->mAttachments.begin();
     10863    for (MediaData::AttachmentList::const_iterator it = mMediaData->mAttachments.begin();
    1093810864         it != mMediaData->mAttachments.end();
    1093910865         ++it)

  • trunk/src/VBox/Main/MediumFormatImpl.cpp

    r30760 r30764  
    2323
    2424#include <VBox/VBoxHDD.h>
    25 
    26 #include <VBox/com/array.h>
    2725
    2826#include <iprt/cpp/utils.h>

  • trunk/src/VBox/Main/MediumImpl.cpp

    r30760 r30764  
    1717
    1818#include "MediumImpl.h"
    19 #include "MediumFormatImpl.h"
    2019#include "ProgressImpl.h"
    2120#include "SystemPropertiesImpl.h"
    2221#include "VirtualBoxImpl.h"
    23 #include "MediumLock.h"
    2422
    2523#include "AutoCaller.h"

  • trunk/src/VBox/Main/MouseImpl.cpp

    r30760 r30764  
    2121#include "DisplayImpl.h"
    2222#include "VMMDev.h"
    23 #include "ConsoleImpl.h"
    2423
    2524#include "AutoCaller.h"
    … …  
    5958    uint32_t                    u32DevCaps;
    6059};
     60
    6161
    6262// constructor / destructor

  • trunk/src/VBox/Main/NATEngineImpl.cpp

    r30760 r30764  
    2727#include <VBox/err.h>
    2828#include <VBox/settings.h>
    29 #include "VBox/com/array.h"
     29
    3030
    3131// constructor / destructor

  • trunk/src/VBox/Main/Performance.cpp

    r30760 r30764  
    133133        ComPtr<IInternalSessionControl> directControl;
    134134
    135         ret = mMachine->getDirectControl(directControl);
     135        ret = mMachine->getDirectControl(&directControl);
    136136        if (ret != S_OK)
    137137            return ret;

  • trunk/src/VBox/Main/PerformanceImpl.cpp

    r30760 r30764  
    2727#include <VBox/err.h>
    2828#include <VBox/settings.h>
    29 
    30 #include <VBox/com/array.h>
    3129
    3230#include <vector>

  • trunk/src/VBox/Main/SnapshotImpl.cpp

    r30760 r30764  
    2121#include "SnapshotImpl.h"
    2222
     23#include "MachineImpl.h"
     24#include "MediumImpl.h"
     25#include "MediumFormatImpl.h"
    2326#include "Global.h"
    24 
    25 #include "AudioAdapterImpl.h"
    26 #include "BIOSSettingsImpl.h"
    27 #include "MachineImplPrivate.h"
    28 #include "MediumImpl.h"
    29 #include "MediumAttachmentImpl.h"
    30 #include "MediumFormatImpl.h"
    31 #include "NetworkAdapterImpl.h"
    32 #include "ParallelPortImpl.h"
    3327#include "ProgressImpl.h"
    34 #include "SerialPortImpl.h"
    35 #include "StorageControllerImpl.h"
    36 #include "VRDPServerImpl.h"
    3728
    3829// @todo these three includes are required for about one or two lines, try
    … …  
    4435#include "AutoCaller.h"
    4536
    46 #include <iprt/file.h>
    4737#include <iprt/path.h>
    4838#include <iprt/cpp/utils.h>
    … …  
    5040#include <VBox/param.h>
    5141#include <VBox/err.h>
    52 
    53 #include <VBox/com/array.h>
    5442
    5543#include <VBox/settings.h>
    … …  
    908896    /* associate hard disks with the snapshot
    909897     * (Machine::uninitDataAndChildObjects() will deassociate at destruction) */
    910     for (MediumAttachmentsList::const_iterator it = mMediaData->mAttachments.begin();
     898    for (MediaData::AttachmentList::const_iterator it = mMediaData->mAttachments.begin();
    911899         it != mMediaData->mAttachments.end();
    912900         ++it)
    … …  
    16071595    ULONG ulOpCount = 1;            // one for preparations
    16081596    ULONG ulTotalWeight = 1;        // one for preparations
    1609     for (MediumAttachmentsList::iterator it = pSnapMachine->mMediaData->mAttachments.begin();
     1597    for (MediaData::AttachmentList::iterator it = pSnapMachine->mMediaData->mAttachments.begin();
    16101598         it != pSnapMachine->mMediaData->mAttachments.end();
    16111599         ++it)
    … …  
    18371825        std::list< ComObjPtr<MediumAttachment> > llDiffAttachmentsToDelete;
    18381826
    1839         for (MediumAttachmentsList::const_iterator it = mMediaData.backedUpData()->mAttachments.begin();
     1827        for (MediaData::AttachmentList::const_iterator it = mMediaData.backedUpData()->mAttachments.begin();
    18401828             it != mMediaData.backedUpData()->mAttachments.end();
    18411829             ++it)
    … …  
    20652053
    20662054    // count normal hard disks and add their sizes to the weight
    2067     for (MediumAttachmentsList::iterator it = pSnapMachine->mMediaData->mAttachments.begin();
     2055    for (MediaData::AttachmentList::iterator it = pSnapMachine->mMediaData->mAttachments.begin();
    20682056         it != pSnapMachine->mMediaData->mAttachments.end();
    20692057         ++it)
    … …  
    22812269        // merge it with its one and only child (the diff image holding the
    22822270        // changes written after the snapshot was taken).
    2283         for (MediumAttachmentsList::iterator it = pSnapMachine->mMediaData->mAttachments.begin();
     2271        for (MediaData::AttachmentList::iterator it = pSnapMachine->mMediaData->mAttachments.begin();
    22842272             it != pSnapMachine->mMediaData->mAttachments.end();
    22852273             ++it)

  • trunk/src/VBox/Main/SystemPropertiesImpl.cpp

    r30760 r30764  
    2121#include "VirtualBoxImpl.h"
    2222#include "MachineImpl.h"
    23 #include "MediumFormatImpl.h"
    24 
    2523#include "AutoCaller.h"
    2624#include "Logging.h"
    … …  
    3937#include <VBox/settings.h>
    4038#include <VBox/VBoxHDD.h>
    41 
    42 #include <VBox/com/array.h>
    4339
    4440// defines

  • trunk/src/VBox/Main/USBControllerImpl.cpp

    r30760 r30764  
    3434#include <VBox/err.h>
    3535#include <VBox/settings.h>
    36 #include <VBox/com/array.h>
    3736
    3837#include <algorithm>

  • trunk/src/VBox/Main/VirtualBoxImpl.cpp

    r30760 r30764  
    6262#include "SystemPropertiesImpl.h"
    6363#include "GuestOSTypeImpl.h"
     64#include "DHCPServerRunner.h"
    6465#include "DHCPServerImpl.h"
    6566#ifdef VBOX_WITH_RESOURCE_USAGE_API
    66 # include "PerformanceImpl.h"
     67#include "PerformanceImpl.h"
    6768#endif /* VBOX_WITH_RESOURCE_USAGE_API */
    6869#include "EventImpl.h"
    … …  
    250251typedef std::map<Guid, ComPtr<IProgress> > ProgressMap;
    251252typedef std::map<Guid, ComObjPtr<Medium> > HardDiskMap;
    252 
    253 typedef std::list< VirtualBoxCallbackRegistration > CallbackList;
    254253
    255254/**

  • trunk/src/VBox/Main/glue/errorprint.cpp

    r30760 r30764  
    2525#include <iprt/stream.h>
    2626#include <iprt/path.h>
    27 
    28 #ifndef DEBUG
    29 // string used by ComAssert macro (VirtualBoxBase.h)
    30 const char *g_pcszComAssertFailedString
    31     = "Assertion failed: [%s] at '%s' (%d) in %s.\nPlease contact the product vendor!";
    32 const char *g_pcszComAssertMsgFailedString
    33     = "Assertion failed: [%s] at '%s' (%d) in %s.\n%s\nPlease contact the product vendor!";
    34 #endif
    3527
    3628namespace com

  • trunk/src/VBox/Main/include/ApplianceImpl.h

    r30760 r30764  
    2424#include "VirtualBoxBase.h"
    2525
     26/* VBox forward declarations */
     27class Progress;
     28class VirtualSystemDescription;
     29struct VirtualSystemDescriptionEntry;
     30
    2631namespace ovf
    2732{
    … …  
    3035    class OVFReader;
    3136    struct DiskImage;
     37}
     38
     39namespace xml
     40{
     41    class ElementNode;
     42}
     43
     44namespace settings
     45{
     46    class MachineConfigFile;
    3247}
    3348

  • trunk/src/VBox/Main/include/ApplianceImplPrivate.h

    r30760 r30764  
    1919#define ____H_APPLIANCEIMPLPRIVATE
    2020
    21 #include "ApplianceImpl.h"
     21class VirtualSystemDescription;
     22
    2223#include "ovfreader.h"
    2324

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

    r30760 r30764  
    2222
    2323#include "VirtualBoxBase.h"
     24
     25namespace settings
     26{
     27    struct AudioAdapter;
     28}
    2429
    2530class ATL_NO_VTABLE AudioAdapter :

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

    r30760 r30764  
    2222
    2323#include "VirtualBoxBase.h"
     24
     25class GuestOSType;
    2426
    2527namespace settings

  • trunk/src/VBox/Main/include/ConsoleImpl.h

    r30760 r30764  
    2424#include "EventImpl.h"
    2525
     26class Guest;
     27class Keyboard;
     28class Mouse;
     29class Display;
     30class MachineDebugger;
     31class TeleporterStateSrc;
     32class OUSBDevice;
     33class RemoteUSBDevice;
     34class SharedFolder;
     35class RemoteDisplayInfo;
     36class AudioSniffer;
     37class ConsoleVRDPServer;
     38class ConsoleCallbackRegistration;      /* See ConsoleImpl.cpp. */
     39class VMMDev;
     40class Progress;
     41
    2642#include <VBox/vrdpapi.h>
    2743#include <VBox/pdmdrv.h>
    … …  
    3652struct VUSBIRHCONFIG;
    3753typedef struct VUSBIRHCONFIG *PVUSBIRHCONFIG;
     54
     55#include <list>
    3856
    3957// defines

  • trunk/src/VBox/Main/include/ConsoleVRDPServer.h

    r30760 r30764  
    2121#define ____H_CONSOLEVRDPSERVER
    2222
    23 class Console;
    24 class RemoteUSBBackend;
    25 
     23#include "RemoteUSBBackend.h"
    2624#include <hgcm/HGCM.h>
    2725
    … …  
    5553{
    5654public:
    57     ConsoleVRDPServer(Console *console);
    58     ~ConsoleVRDPServer();
     55    ConsoleVRDPServer (Console *console);
     56    ~ConsoleVRDPServer ();
    5957
    6058    int Launch (void);

  • trunk/src/VBox/Main/include/DHCPServerImpl.h

    r30760 r30764  
    2222
    2323#include "VirtualBoxBase.h"
    24 
    25 #include "DHCPServerRunner.h"
    2624
    2725#ifdef VBOX_WITH_HOSTNETIF_API

  • trunk/src/VBox/Main/include/GuestImpl.h

    r30760 r30764  
    4141    GUESTSTATTYPE_MAX         = 9
    4242} GUESTSTATTYPE;
     43
     44class Console;
     45#ifdef VBOX_WITH_GUEST_CONTROL
     46class Progress;
     47#endif
    4348
    4449class ATL_NO_VTABLE Guest :

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

    r30760 r30764  
    2020
    2121#include "VirtualBoxBase.h"
     22
     23class HostUSBDeviceFilter;
     24class USBProxyService;
     25class SessionMachine;
     26class Progress;
     27class PerformanceCollector;
     28
     29namespace settings
     30{
     31    struct Host;
     32}
     33
     34#include <list>
    2235
    2336class ATL_NO_VTABLE Host :

  • trunk/src/VBox/Main/include/KeyboardImpl.h

    r30760 r30764  
    2020
    2121#include "VirtualBoxBase.h"
     22#include "ConsoleEvents.h"
    2223
    2324#include <VBox/pdmdrv.h>
    … …  
    2526/** Limit of simultaneously attached devices (just USB and/or PS/2). */
    2627enum { KEYBOARD_MAX_DEVICES = 2 };
     28
     29/** Simple keyboard event class. */
     30class KeyboardEvent
     31{
     32public:
     33    KeyboardEvent() : scan(-1) {}
     34    KeyboardEvent(int _scan) : scan(_scan) {}
     35    bool isValid()
     36    {
     37        return (scan & ~0x80) && !(scan & ~0xFF);
     38    }
     39    int scan;
     40};
     41// template instantiation
     42typedef ConsoleEventBuffer<KeyboardEvent> KeyboardEventBuffer;
    2743
    2844class Console;

  • trunk/src/VBox/Main/include/MachineDebuggerImpl.h

    r30760 r30764  
    2222
    2323#include "VirtualBoxBase.h"
     24
     25class Console;
    2426
    2527class ATL_NO_VTABLE MachineDebugger :

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

    r30760 r30764  
    2121#include "VirtualBoxBase.h"
    2222#include "SnapshotImpl.h"
     23#include "VRDPServerImpl.h"
     24#include "MediumAttachmentImpl.h"
     25#include "MediumLock.h"
     26#include "NetworkAdapterImpl.h"
     27#include "AudioAdapterImpl.h"
     28#include "SerialPortImpl.h"
     29#include "ParallelPortImpl.h"
     30#include "BIOSSettingsImpl.h"
     31#include "StorageControllerImpl.h"          // required for MachineImpl.h to compile on Windows
     32#include "VBox/settings.h"
     33#ifdef VBOX_WITH_RESOURCE_USAGE_API
     34#include "Performance.h"
     35#include "PerformanceImpl.h"
     36#endif /* VBOX_WITH_RESOURCE_USAGE_API */
    2337
    2438// generated header
    … …  
    2741#include "VBox/com/ErrorInfo.h"
    2842
     43#include <iprt/file.h>
     44#include <iprt/thread.h>
     45#include <iprt/time.h>
     46
    2947#include <list>
     48
     49// defines
     50////////////////////////////////////////////////////////////////////////////////
     51
     52// helper declarations
     53////////////////////////////////////////////////////////////////////////////////
     54
     55class Progress;
     56class ProgressProxy;
     57class Keyboard;
     58class Mouse;
     59class Display;
     60class MachineDebugger;
     61class USBController;
     62class Snapshot;
     63class SharedFolder;
     64class HostUSBDevice;
     65class StorageController;
     66
     67class SessionMachine;
     68
     69namespace settings
     70{
     71    class MachineConfigFile;
     72    struct Snapshot;
     73    struct Hardware;
     74    struct Storage;
     75    struct StorageController;
     76    struct MachineRegistryEntry;
     77}
    3078
    3179// Machine class
    … …  
    4593    };
    4694
    47     struct Data;            // machine data
    48     struct SSData;          // saved state data
    49     struct UserData;        // user data
    50     struct HWData;          // hardware data
    51     struct MediaData;       // media data
     95    /**
     96     * Internal machine data.
     97     *
     98     * Only one instance of this data exists per every machine -- it is shared
     99     * by the Machine, SessionMachine and all SnapshotMachine instances
     100     * associated with the given machine using the util::Shareable template
     101     * through the mData variable.
     102     *
     103     * @note |const| members are persistent during lifetime so can be
     104     * accessed without locking.
     105     *
     106     * @note There is no need to lock anything inside init() or uninit()
     107     * methods, because they are always serialized (see AutoCaller).
     108     */
     109    struct Data
     110    {
     111        /**
     112         * Data structure to hold information about sessions opened for the
     113         * given machine.
     114         */
     115        struct Session
     116        {
     117            /** Control of the direct session opened by openSession() */
     118            ComPtr<IInternalSessionControl> mDirectControl;
     119
     120            typedef std::list<ComPtr<IInternalSessionControl> > RemoteControlList;
     121
     122            /** list of controls of all opened remote sessions */
     123            RemoteControlList mRemoteControls;
     124
     125            /** openRemoteSession() and OnSessionEnd() progress indicator */
     126            ComObjPtr<ProgressProxy> mProgress;
     127
     128            /**
     129             * PID of the session object that must be passed to openSession() to
     130             * finalize the openRemoteSession() request (i.e., PID of the
     131             * process created by openRemoteSession())
     132             */
     133            RTPROCESS mPid;
     134
     135            /** Current session state */
     136            SessionState_T mState;
     137
     138            /** Session type string (for indirect sessions) */
     139            Bstr mType;
     140
     141            /** Session machine object */
     142            ComObjPtr<SessionMachine> mMachine;
     143
     144            /** Medium object lock collection. */
     145            MediumLockListMap mLockedMedia;
     146        };
     147
     148        Data();
     149        ~Data();
     150
     151        const Guid          mUuid;
     152        BOOL                mRegistered;
     153
     154        /** Flag indicating that the config file is read-only. */
     155        Utf8Str             m_strConfigFile;
     156        Utf8Str             m_strConfigFileFull;
     157
     158        // machine settings XML file
     159        settings::MachineConfigFile *pMachineConfigFile;
     160        uint32_t            flModifications;
     161
     162        BOOL                mAccessible;
     163        com::ErrorInfo      mAccessError;
     164
     165        MachineState_T      mMachineState;
     166        RTTIMESPEC          mLastStateChange;
     167
     168        /* Note: These are guarded by VirtualBoxBase::stateLockHandle() */
     169        uint32_t            mMachineStateDeps;
     170        RTSEMEVENTMULTI     mMachineStateDepsSem;
     171        uint32_t            mMachineStateChangePending;
     172
     173        BOOL                mCurrentStateModified;
     174        /** Guest properties have been modified and need saving since the
     175         * machine was started, or there are transient properties which need
     176         * deleting and the machine is being shut down. */
     177        BOOL                mGuestPropertiesModified;
     178
     179        Session             mSession;
     180
     181        ComObjPtr<Snapshot> mFirstSnapshot;
     182        ComObjPtr<Snapshot> mCurrentSnapshot;
     183    };
     184
     185    /**
     186     *  Saved state data.
     187     *
     188     *  It's actually only the state file path string, but it needs to be
     189     *  separate from Data, because Machine and SessionMachine instances
     190     *  share it, while SnapshotMachine does not.
     191     *
     192     *  The data variable is |mSSData|.
     193     */
     194    struct SSData
     195    {
     196        Utf8Str mStateFilePath;
     197    };
     198
     199    /**
     200     *  User changeable machine data.
     201     *
     202     *  This data is common for all machine snapshots, i.e. it is shared
     203     *  by all SnapshotMachine instances associated with the given machine
     204     *  using the util::Backupable template through the |mUserData| variable.
     205     *
     206     *  SessionMachine instances can alter this data and discard changes.
     207     *
     208     *  @note There is no need to lock anything inside init() or uninit()
     209     *  methods, because they are always serialized (see AutoCaller).
     210     */
     211    struct UserData
     212    {
     213        UserData();
     214        ~UserData();
     215
     216        Bstr    mName;
     217        BOOL    mNameSync;
     218        Bstr    mDescription;
     219        Bstr    mOSTypeId;
     220        Bstr    mSnapshotFolder;
     221        Bstr    mSnapshotFolderFull;
     222        BOOL    mTeleporterEnabled;
     223        ULONG   mTeleporterPort;
     224        Bstr    mTeleporterAddress;
     225        Bstr    mTeleporterPassword;
     226        BOOL    mRTCUseUTC;
     227    };
     228
     229    /**
     230     *  Hardware data.
     231     *
     232     *  This data is unique for a machine and for every machine snapshot.
     233     *  Stored using the util::Backupable template in the |mHWData| variable.
     234     *
     235     *  SessionMachine instances can alter this data and discard changes.
     236     */
     237    struct HWData
     238    {
     239        /**
     240         * Data structure to hold information about a guest property.
     241         */
     242        struct GuestProperty {
     243            /** Property name */
     244            Utf8Str strName;
     245            /** Property value */
     246            Utf8Str strValue;
     247            /** Property timestamp */
     248            ULONG64 mTimestamp;
     249            /** Property flags */
     250            ULONG mFlags;
     251        };
     252
     253        HWData();
     254        ~HWData();
     255
     256        Bstr                 mHWVersion;
     257        Guid                 mHardwareUUID;   /**< If Null, use mData.mUuid. */
     258        ULONG                mMemorySize;
     259        ULONG                mMemoryBalloonSize;
     260        BOOL                 mPageFusionEnabled;
     261        ULONG                mVRAMSize;
     262        ULONG                mMonitorCount;
     263        BOOL                 mHWVirtExEnabled;
     264        BOOL                 mHWVirtExExclusive;
     265        BOOL                 mHWVirtExNestedPagingEnabled;
     266        BOOL                 mHWVirtExLargePagesEnabled;
     267        BOOL                 mHWVirtExVPIDEnabled;
     268        BOOL                 mAccelerate2DVideoEnabled;
     269        BOOL                 mPAEEnabled;
     270        BOOL                 mSyntheticCpu;
     271        ULONG                mCPUCount;
     272        BOOL                 mCPUHotPlugEnabled;
     273        BOOL                 mAccelerate3DEnabled;
     274        BOOL                 mHpetEnabled;
     275
     276        BOOL                 mCPUAttached[SchemaDefs::MaxCPUCount];
     277
     278        settings::CpuIdLeaf  mCpuIdStdLeafs[10];
     279        settings::CpuIdLeaf  mCpuIdExtLeafs[10];
     280
     281        DeviceType_T         mBootOrder[SchemaDefs::MaxBootPosition];
     282
     283        typedef std::list< ComObjPtr<SharedFolder> > SharedFolderList;
     284        SharedFolderList     mSharedFolders;
     285
     286        ClipboardMode_T      mClipboardMode;
     287
     288        typedef std::list<GuestProperty> GuestPropertyList;
     289        GuestPropertyList    mGuestProperties;
     290        Utf8Str              mGuestPropertyNotificationPatterns;
     291
     292        FirmwareType_T       mFirmwareType;
     293        KeyboardHidType_T    mKeyboardHidType;
     294        PointingHidType_T    mPointingHidType;
     295
     296        BOOL                 mIoCacheEnabled;
     297        ULONG                mIoCacheSize;
     298        ULONG                mIoBandwidthMax;
     299    };
     300
     301    /**
     302     *  Hard disk and other media data.
     303     *
     304     *  The usage policy is the same as for HWData, but a separate structure
     305     *  is necessary because hard disk data requires different procedures when
     306     *  taking or deleting snapshots, etc.
     307     *
     308     *  The data variable is |mMediaData|.
     309     */
     310    struct MediaData
     311    {
     312        MediaData();
     313        ~MediaData();
     314
     315        typedef std::list< ComObjPtr<MediumAttachment> > AttachmentList;
     316        AttachmentList mAttachments;
     317    };
    52318
    53319    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(Machine, IMachine)
    … …  
    265531    //  that use it. Note: they should enter Machine lock to keep the returned
    266532    //  information valid!
    267     bool isRegistered() const;
     533    bool isRegistered() { return !!mData->mRegistered; }
    268534
    269535    // unsafe inline public methods for internal purposes only (ensure there is
    … …  
    279545    VirtualBox* getVirtualBox() const { return mParent; }
    280546
    281     const Guid& getId() const;
    282 
    283547    /**
    284      * Virtual method that returns the snapshot a Machine object is attached
    285      * to. This implementation returns Guid::Empty, but the SnapshotMachine
    286      * override will return a real snapshot ID.
     548     * Returns this machine ID.
     549     *
     550     * @note This method doesn't check this object's readiness. Intended to be
     551     * used by ready Machine children (whose readiness is bound to the parent's
     552     * one) or after adding a caller manually.
    287553     */
    288     virtual const Guid& getSnapshotId() const
    289     {
    290         return Guid::Empty;
    291     }
    292 
    293     const Utf8Str& getSettingsFileFull() const;
    294 
    295     const Bstr& getName() const;
     554    const Guid& getId() const { return mData->mUuid; }
     555
     556    /**
     557     * Returns the snapshot ID this machine represents or an empty UUID if this
     558     * instance is not SnapshotMachine.
     559     *
     560     * @note This method doesn't check this object's readiness. Intended to be
     561     * used by ready Machine children (whose readiness is bound to the parent's
     562     * one) or after adding a caller manually.
     563     */
     564    inline const Guid& getSnapshotId() const;
     565
     566    /**
     567     * Returns this machine's full settings file path.
     568     *
     569     * @note This method doesn't lock this object or check its readiness.
     570     * Intended to be used only after doing addCaller() manually and locking it
     571     * for reading.
     572     */
     573    const Utf8Str& getSettingsFileFull() const { return mData->m_strConfigFileFull; }
     574
     575    /**
     576     * Returns this machine name.
     577     *
     578     * @note This method doesn't lock this object or check its readiness.
     579     * Intended to be used only after doing addCaller() manually and locking it
     580     * for reading.
     581     */
     582    const Bstr& getName() const { return mUserData->mName; }
    296583
    297584    enum
    … …  
    337624    HRESULT openExistingSession(IInternalSessionControl *aControl);
    338625
    339     HRESULT getDirectControl(ComPtr<IInternalSessionControl> &directControl);
     626    HRESULT getDirectControl(ComPtr<IInternalSessionControl> *directControl)
     627    {
     628        HRESULT rc;
     629        *directControl = mData->mSession.mDirectControl;
     630
     631        if (!*directControl)
     632            rc = E_ACCESSDENIED;
     633        else
     634            rc = S_OK;
     635
     636        return rc;
     637    }
    340638
    341639#if defined(RT_OS_WINDOWS)
    … …  
    343641    bool isSessionOpen(ComObjPtr<SessionMachine> &aMachine,
    344642                       ComPtr<IInternalSessionControl> *aControl = NULL,
    345                        HANDLE *aIPCSem = NULL,
    346                        bool aAllowClosing = false);
     643                       HANDLE *aIPCSem = NULL, bool aAllowClosing = false);
    347644    bool isSessionSpawning(RTPROCESS *aPID = NULL);
    348645
    … …  
    356653    bool isSessionOpen(ComObjPtr<SessionMachine> &aMachine,
    357654                       ComPtr<IInternalSessionControl> *aControl = NULL,
    358                        HMTX *aIPCSem = NULL,
    359                        bool aAllowClosing = false);
     655                       HMTX *aIPCSem = NULL, bool aAllowClosing = false);
    360656
    361657    bool isSessionSpawning(RTPROCESS *aPID = NULL);
    … …  
    432728
    433729    HRESULT getMediumAttachmentsOfController(CBSTR aName,
    434                                              MediumAttachmentsList &aAttachments);
     730                                             MediaData::AttachmentList &aAttachments);
    435731
    436732    enum
    … …  
    464760    HRESULT deleteImplicitDiffs(bool *pfNeedsSaveSettings);
    465761
    466     MediumAttachment* findAttachment(const MediumAttachmentsList &ll,
     762    MediumAttachment* findAttachment(const MediaData::AttachmentList &ll,
    467763                                     IN_BSTR aControllerName,
    468764                                     LONG aControllerPort,
    469765                                     LONG aDevice);
    470     MediumAttachment* findAttachment(const MediumAttachmentsList &ll,
     766    MediumAttachment* findAttachment(const MediaData::AttachmentList &ll,
    471767                                     ComObjPtr<Medium> pMedium);
    472     MediumAttachment* findAttachment(const MediumAttachmentsList &ll,
     768    MediumAttachment* findAttachment(const MediaData::AttachmentList &ll,
    473769                                     Guid &id);
    474770
    … …  
    8061102    // a caller and a read lock before calling them!)
    8071103
    808     /**
    809      * Override of Machine::getSnapshotId(). Whereas the parent returns an empty Guid,
    810      * this returns the snapshot that this machine is attached to.
    811      * @return
    812      */
    813     virtual const Guid& getSnapshotId() const
    814     {
    815         return mSnapshotId;
    816     }
     1104    const Guid& getSnapshotId() const { return mSnapshotId; }
    8171105
    8181106private:
    … …  
    8231111};
    8241112
     1113// third party methods that depend on SnapshotMachine definiton
     1114
     1115inline const Guid &Machine::getSnapshotId() const
     1116{
     1117    return (isSnapshotMachine())
     1118                ? static_cast<const SnapshotMachine*>(this)->getSnapshotId()
     1119                : Guid::Empty;
     1120}
     1121
     1122
    8251123#endif // ____H_MACHINEIMPL
     1124/* vi: set tabstop=4 shiftwidth=4 expandtab: */

  • trunk/src/VBox/Main/include/MediumFormatImpl.h

    r30760 r30764  
    2222
    2323#include "VirtualBoxBase.h"
     24
     25#include <VBox/com/array.h>
     26
     27#include <list>
    2428
    2529struct VDBACKENDINFO;

  • trunk/src/VBox/Main/include/MediumImpl.h

    r30760 r30764  
    2222
    2323#include "VirtualBoxBase.h"
     24#include "MediumLock.h"
     25
     26class Progress;
     27class MediumFormat;
     28
     29namespace settings
     30{
     31    struct Medium;
     32}
    2433
    2534////////////////////////////////////////////////////////////////////////////////

  • trunk/src/VBox/Main/include/MediumLock.h

    r30760 r30764  
    2121#define ____H_MEDIUMLOCK
    2222
     23/* interface definitions */
     24#include "VBox/com/VirtualBox.h"
    2325#include "VirtualBoxBase.h"
    2426#include "AutoCaller.h"
     27
     28#include <iprt/types.h>
     29
     30#include <list>
     31#include <map>
     32
     33class Medium;
     34class MediumAttachment;
    2535
    2636/**

  • trunk/src/VBox/Main/include/MouseImpl.h

    r30760 r30764  
    2020
    2121#include "VirtualBoxBase.h"
     22#include "ConsoleEvents.h"
     23#include "ConsoleImpl.h"
    2224#include <VBox/pdmdrv.h>
    2325
    … …  
    2729typedef struct DRVMAINMOUSE DRVMAINMOUSE, *PDRVMAINMOUSE;
    2830
    29 class Console;
     31/** Simple mouse event class. */
     32class MouseEvent
     33{
     34public:
     35    MouseEvent() : dx(0), dy(0), dz(0), dw(0), state(-1) {}
     36    MouseEvent(int32_t _dx, int32_t _dy, int32_t _dz, int32_t _dw, int32_t _state) :
     37        dx(_dx), dy(_dy), dz(_dz), dw(_dw), state(_state) {}
     38    bool isValid()
     39    {
     40        return state != -1;
     41    }
     42    /* Note: dw is the horizontal scroll wheel */
     43    int32_t dx, dy, dz, dw;
     44    int32_t state;
     45};
     46// template instantiation
     47typedef ConsoleEventBuffer<MouseEvent> MouseEventBuffer;
    3048
    3149class ATL_NO_VTABLE Mouse :

  • trunk/src/VBox/Main/include/NATEngineImpl.h

    r30760 r30764  
    2424#include "VirtualBoxBase.h"
    2525#include <VBox/settings.h>
     26
     27namespace settings
     28{
     29    struct NAT;
     30}
    2631
    2732class ATL_NO_VTABLE NATEngine :

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

    r30760 r30764  
    2222
    2323#include "VirtualBoxBase.h"
     24#include "NATEngineImpl.h"
     25
     26class GuestOSType;
     27
     28namespace settings
     29{
     30    struct NetworkAdapter;
     31}
    2432
    2533class ATL_NO_VTABLE NetworkAdapter :

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

    r30760 r30764  
    2121
    2222#include "VirtualBoxBase.h"
     23
     24namespace settings
     25{
     26    struct ParallelPort;
     27}
    2328
    2429class ATL_NO_VTABLE ParallelPort :
    … …  
    4651
    4752    // public initializer/uninitializer for internal purposes only
    48     HRESULT init(Machine *aParent, ULONG aSlot);
    49     HRESULT init(Machine *aParent, ParallelPort *aThat);
     53    HRESULT init (Machine *aParent, ULONG aSlot);
     54    HRESULT init (Machine *aParent, ParallelPort *aThat);
    5055    HRESULT initCopy (Machine *parent, ParallelPort *aThat);
    5156    void uninit();

  • trunk/src/VBox/Main/include/PerformanceImpl.h

    r30760 r30764  
    2323#include "VirtualBoxBase.h"
    2424
    25 // #include <VBox/com/com.h>
    26 // #include <VBox/com/array.h>
     25#include <VBox/com/com.h>
     26#include <VBox/com/array.h>
     27//#ifdef VBOX_WITH_RESOURCE_USAGE_API
    2728#include <iprt/timer.h>
     29//#endif /* VBOX_WITH_RESOURCE_USAGE_API */
     30
     31#include <list>
     32
     33namespace pm
     34{
     35    class Metric;
     36    class BaseMetric;
     37    class CollectorHAL;
     38}
    2839
    2940#undef min
    … …  
    3243/* Each second we obtain new CPU load stats. */
    3344#define VBOX_USAGE_SAMPLER_MIN_INTERVAL 1000
     45
     46class HostUSBDevice;
    3447
    3548class ATL_NO_VTABLE PerformanceMetric :

  • trunk/src/VBox/Main/include/RemoteUSBBackend.h

    r30760 r30764  
    3333//} RDLState;
    3434
     35class Console;
     36class ConsoleVRDPServer;
     37
    3538DECLCALLBACK(int) USBClientResponseCallback (void *pv, uint32_t u32ClientId, uint8_t code, const void *pvRet, uint32_t cbRet);
     39
    3640
    3741/* How many remote devices can be attached to a remote client.

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

    r30760 r30764  
    2222
    2323#include "VirtualBoxBase.h"
     24
     25class GuestOSType;
     26
     27namespace settings
     28{
     29    struct SerialPort;
     30}
    2431
    2532class ATL_NO_VTABLE SerialPort :

  • trunk/src/VBox/Main/include/SessionImpl.h

    r30760 r30764  
    2020
    2121#include "VirtualBoxBase.h"
     22#include "ConsoleImpl.h"
    2223
    2324#ifdef RT_OS_WINDOWS

  • trunk/src/VBox/Main/include/SharedFolderImpl.h

    r30760 r30764  
    2121#include "VirtualBoxBase.h"
    2222#include <VBox/shflsvc.h>
     23
     24class Console;
    2325
    2426class ATL_NO_VTABLE SharedFolder :

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

    r30760 r30764  
    2424
    2525#include <iprt/time.h>
     26
     27class SnapshotMachine;
     28
     29namespace settings
     30{
     31    struct Snapshot;
     32}
    2633
    2734class ATL_NO_VTABLE Snapshot :

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

    r30760 r30764  
    2222
    2323#include "VirtualBoxBase.h"
     24#include "MediumFormatImpl.h"
     25
     26#include <VBox/com/array.h>
     27
     28#include <list>
     29
     30namespace settings
     31{
     32    struct SystemProperties;
     33}
    2434
    2535class ATL_NO_VTABLE SystemProperties :

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

    r30760 r30764  
    2222
    2323#include "VirtualBoxBase.h"
     24
     25class HostUSBDevice;
     26class USBDeviceFilter;
     27
     28namespace settings
     29{
     30    struct USBController;
     31}
    2432
    2533class ATL_NO_VTABLE USBController :

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

    r30763 r30764  
    3030#include "VBox/com/VirtualBox.h"
    3131
    32 // empty-declare a bunch of classes that are commonly used in VirtualBox
    33 // headers; this avoids having to include all the headers in every
    34 // single implementation .cpp file
    35 
     32// avoid including VBox/settings.h and VBox/xml.h;
     33// only declare the classes
    3634namespace xml
    3735{
    38     class ElementNode;
    39     class File;
     36class File;
    4037}
    4138
    … …  
    4643class AutoUninitSpan;
    4744
    48 class AudioSniffer;
    49 class AudioAdapter;
    50 class Appliance;
    51 class BIOSSettings;
    52 class Console;
    53 class ConsoleCallbackRegistration;
    54 class ConsoleVRDPServer;
    55 class DHCPServer;
    56 class Display;
    57 class Guest;
    58 class GuestOSType;
     45class VirtualBox;
     46class Machine;
     47class Medium;
    5948class Host;
    60 class HostUSBDevice;
    61 class HostUSBDeviceFilter;
    62 class Keyboard;
    63 class Machine;
    64 class MachineDebugger;
    65 class Medium;
    66 class MediumAttachment;
    67 class MediumFormat;
    68 class MediumLockList;
    69 class Mouse;
    70 class NetworkAdapter;
    71 class NATEngine;
    72 class OUSBDevice;
    73 class ParallelPort;
    74 class PerformanceCollector;
    75 class Progress;
    76 class ProgressProxy;
    77 class RemoteDisplayInfo;
    78 class RemoteUSBDevice;
    79 class SerialPort;
    80 class SessionMachine;
    81 class SharedFolder;
    82 class Snapshot;
    83 class SnapshotMachine;
    84 class StorageController;
    85 class SystemProperties;
    86 class USBController;
    87 class USBDeviceFilter;
    88 class USBProxyService;
    89 class TeleporterStateSrc;
    90 class VMMDev;
    91 class VirtualBox;
    92 class VirtualSystemDescription;
    93 struct VirtualSystemDescriptionEntry;
    94 class VRDPServer;
    95 
    9649typedef std::list< ComObjPtr<Medium> > MediaList;
    97 typedef std::list< ComObjPtr<MediumAttachment> > MediumAttachmentsList;
    98 
    99 namespace settings
    100 {
    101     struct AudioAdapter;
    102     struct Hardware;
    103     struct Host;
    104     class  MainConfigFile;
    105     class  MachineConfigFile;
    106     struct MachineRegistryEntry;
    107     struct Medium;
    108     struct NAT;
    109     struct NetworkAdapter;
    110     struct ParallelPort;
    111     struct SerialPort;
    112     struct Snapshot;
    113     struct Storage;
    114     struct StorageController;
    115     struct SystemProperties;
    116     struct USBController;
    117 }
    118 
    119 namespace pm
    120 {
    121     class Metric;
    122     class BaseMetric;
    123     class CollectorHAL;
    124     class CollectorGuestHAL;
    125 }
    12650
    12751////////////////////////////////////////////////////////////////////////////////
    … …  
    215139////////////////////////////////////////////////////////////////////////////////
    216140
    217 #ifndef DEBUG
    218     // the following two are defined in glue/errorprint.cpp because they are included
    219     // in the ComAssert macro below thousands of times in release builds
    220 extern const char *g_pcszComAssertFailedString;
    221     // "Assertion failed: [%s] at '%s' (%d) in %s.\nPlease contact the product vendor!"
    222 extern const char *g_pcszComAssertMsgFailedString;
    223     // "Assertion failed: [%s] at '%s' (%d) in %s.\n%s\nPlease contact the product vendor!"
    224 #endif
    225 
    226141/**
    227142 *  Special version of the Assert macro to be used within VirtualBoxBase
    … …  
    243158        if (RT_UNLIKELY(!(expr))) \
    244159            setError(E_FAIL, \
    245                      g_pcszComAssertFailedString, \
     160                     "Assertion failed: [%s] at '%s' (%d) in %s.\nPlease contact the product vendor!", \
    246161                     #expr, __FILE__, __LINE__, __PRETTY_FUNCTION__); \
    247162    } while (0)
    … …  
    264179        if (RT_UNLIKELY(!(expr))) \
    265180            setError(E_FAIL, \
    266                      g_pcszComAssertMsgFailedString, \
    267                      #expr, __FILE__, __LINE__, __PRETTY_FUNCTION__, Utf8StrFmt a .c_str()); \
     181                     "Assertion failed: [%s] at '%s' (%d) in %s.\n%s.\nPlease contact the product vendor!", \
     182                     #expr, __FILE__, __LINE__, __PRETTY_FUNCTION__); \
    268183    } while (0)
    269184#endif

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

    r30760 r30764  
    3333}
    3434
     35class SessionMachine;
     36class GuestOSType;
     37class SharedFolder;
     38class Progress;
     39class Host;
     40class SystemProperties;
     41class DHCPServer;
     42class PerformanceCollector;
     43class VirtualBoxCallbackRegistration; /* see VirtualBoxImpl.cpp */
     44
    3545typedef std::list< ComObjPtr<SessionMachine> > SessionMachinesList;
    3646
    … …  
    4050
    4151struct VMClientWatcherData;
     52
     53namespace settings
     54{
     55    class MainConfigFile;
     56}
    4257
    4358class ATL_NO_VTABLE VirtualBox :
    … …  
    5368public:
    5469
     70    typedef std::list< VirtualBoxCallbackRegistration > CallbackList;
    5571    typedef std::list< ComPtr<IInternalSessionControl> > InternalControlList;
    5672

  • trunk/src/VBox/Main/xpcom/server.cpp

    r30760 r30764  
    4141#include <iprt/message.h>
    4242#include <iprt/stream.h>
    43 #include <iprt/file.h>
    4443#include <iprt/path.h>
    4544#include <iprt/timer.h>
    … …  
    6160#include <VirtualBox_XPCOM.h>
    6261#include <VirtualBoxImpl.h>
    63 
    64 #include "AudioAdapterImpl.h"
    65 #include "ApplianceImpl.h"
    66 #include "BIOSSettingsImpl.h"
    67 #include "GuestOSTypeImpl.h"
     62#include <MachineImpl.h>
     63#include <VFSExplorerImpl.h>
     64#include <ApplianceImpl.h>
     65#include <SnapshotImpl.h>
     66#include <MediumImpl.h>
     67#include <MediumFormatImpl.h>
     68#include <ProgressCombinedImpl.h>
     69#include <ProgressProxyImpl.h>
     70#include <VRDPServerImpl.h>
     71#include <SharedFolderImpl.h>
     72#include <HostImpl.h>
     73#include <HostNetworkInterfaceImpl.h>
     74#include <GuestOSTypeImpl.h>
     75#include <NetworkAdapterImpl.h>
     76#include <NATEngineImpl.h>
     77#include <SerialPortImpl.h>
     78#include <ParallelPortImpl.h>
     79#include <USBControllerImpl.h>
     80#include "USBDeviceFilterImpl.h"
     81#include "DHCPServerRunner.h"
    6882#include "DHCPServerImpl.h"
    69 #include "HostImpl.h"
    70 #include "HostNetworkInterfaceImpl.h"
    71 #include "MachineImpl.h"
    72 #include "MediumImpl.h"
    73 #include "MediumAttachmentImpl.h"
    74 #include "MediumFormatImpl.h"
    75 #include "NATEngineImpl.h"
    76 #include "NetworkAdapterImpl.h"
    77 #include "ParallelPortImpl.h"
    78 #include "ProgressCombinedImpl.h"
    79 #include "ProgressProxyImpl.h"
    80 #include "VRDPServerImpl.h"
    81 #include "SerialPortImpl.h"
    82 #include "SharedFolderImpl.h"
    83 #include "SnapshotImpl.h"
    84 #include "StorageControllerImpl.h"
    85 #include "SystemPropertiesImpl.h"
    86 #include "USBDeviceFilterImpl.h"
    87 #include "USBControllerImpl.h"
    88 #include "VFSExplorerImpl.h"
    89 
    9083#ifdef VBOX_WITH_USB
    9184# include <HostUSBDeviceImpl.h>
    9285# include <USBDeviceImpl.h>
    9386#endif
    94 
    95 #ifdef VBOX_WITH_RESOURCE_USAGE_API
    96 # include "Performance.h"
    97 # include "PerformanceImpl.h"
    98 #endif /* VBOX_WITH_RESOURCE_USAGE_API */
     87#include <StorageControllerImpl.h>
     88#include <AudioAdapterImpl.h>
     89#include <SystemPropertiesImpl.h>
    9990
    10091/* implement nsISupports parts of our objects with support for nsIClassInfo */
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette