/*
* DO NOT EDIT! This is a generated file.
*
* XPCOM IDL (XPIDL) definition for VirtualBox Main API (COM interfaces)
* generated from XIDL (XML interface definition).
*
* Source : src/VBox/Main/idl/VirtualBox.xidl
* Generator : src/VBox/Main/idl/xpcidl.xsl
*
* This file contains portions from the following Mozilla XPCOM files:
*
* elects to distribute this derived work under the LGPL2.1 only.
*/
/*
* Copyright (C) 2008-2012 Oracle Corporation
*
* This file is part of a free software library; you can redistribute
* Public License version 2.1 as published by the Free Software
* Foundation and shipped in the "COPYING" file with this library.
* The library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY of any kind.
*
* Oracle LGPL Disclaimer: For the avoidance of doubt, except that if
* any license choice other than GPL or LGPL is available it will
* apply instead, Oracle elects to use only the Lesser General Public
* License version 2.1 (LGPLv2) at this time for any software where
* a choice of LGPL license versions is made available with the
* language indicating that LGPLv2 or any later version may be used,
* or where a choice of which version of the LGPL is applied is
* otherwise unspecified.
*/
#ifndef ___VirtualBox_CXPCOM_h
#define ___VirtualBox_CXPCOM_h
#ifdef __cplusplus
# include "VirtualBox_XPCOM.h"
#else /* !__cplusplus */
#include <stddef.h>
#include "wchar.h"
#if defined(WIN32)
#define PR_CALLBACK
#define PR_CALLBACK_DECL
#define PR_CALLBACK
#define PR_CALLBACK_DECL
#if defined(_WINDLL)
#else /* this must be .EXE */
#endif /* _WINDLL */
#define PR_CALLBACK
#define PR_CALLBACK_DECL
#define PR_CALLBACK
#define PR_CALLBACK_DECL
#elif defined(XP_OS2_VACPP)
#define PR_CALLBACK_DECL
#else /* Unix */
# ifdef VBOX_HAVE_VISIBILITY_HIDDEN
# define PR_CALLBACK
# define PR_CALLBACK_DECL
# else
# define PR_CALLBACK
# define PR_CALLBACK_DECL
# endif
#endif
#if defined(_NSPR_BUILD_)
#else
#endif
typedef unsigned char PRUint8;
#if (defined(HPUX) && defined(__cplusplus) \
|| (defined(SCO) && defined(__cplusplus) \
typedef char PRInt8;
#else
typedef signed char PRInt8;
#endif
typedef unsigned short PRUint16;
typedef short PRInt16;
typedef unsigned int PRUint32;
typedef int PRInt32;
#define PR_INT32(x) x
#define PR_UINT32(x) x ## U
typedef long PRInt64;
typedef unsigned long PRUint64;
typedef int PRIntn;
typedef unsigned int PRUintn;
typedef double PRFloat64;
typedef unsigned long PRUptrdiff;
#define PR_FALSE 0
/*
** Status code used by some routines that have a single point of failure or
** special status return.
*/
#ifndef __PRUNICHAR__
#define __PRUNICHAR__
#else
#endif
#endif
typedef long PRWord;
typedef unsigned long PRUword;
#define nsnull 0
#else
#define NS_LIKELY(x) (x)
#define NS_UNLIKELY(x) (x)
#endif
#endif /* VBOX_WITH_XPCOM_NAMESPACE_CLEANUP */
#endif /* VBOX_WITH_XPCOM_NAMESPACE_CLEANUP */
typedef enum PRThreadType {
} PRThreadType;
typedef enum PRThreadScope {
typedef enum PRThreadState {
typedef enum PRThreadPriority
{
void *arg,
#ifndef NO_NSPR_10_SUPPORT
#endif /* NO_NSPR_10_SUPPORT */
NSPR_API(void) PR_ClearInterrupt(void);
NSPR_API(void) PR_BlockInterrupt(void);
NSPR_API(void) PR_UnblockInterrupt(void);
#endif /* VBOX_WITH_XPCOM_NAMESPACE_CLEANUP */
#endif /* VBOX_WITH_XPCOM_NAMESPACE_CLEANUP */
struct PRCListStr {
};
#endif /* VBOX_WITH_XPCOM_NAMESPACE_CLEANUP */
const char *name,
);
const char *name,
);
PR_EXTERN(void)
PR_EXTERN(void)
PR_EXTERN(void) PL_FavorPerformanceHint(PRBool favorPerformanceOverEventStarvation, PRUint32 starvationDelay);
struct PLEvent {
void* owner;
void* synchronousResult;
#ifdef PL_POST_TIMINGS
#endif
#ifdef XP_UNIX
unsigned long id;
#endif /* XP_UNIX */
/* other fields follow... */
};
);
#endif /* XP_WIN || XP_OS2 */
#ifdef XP_UNIX
PR_EXTERN(void)
void *aClosure);
#endif /* XP_UNIX */
/* Standard "it worked" return value */
#define NS_OK 0
/* Returned when an instance is not initialized */
/* Returned when an instance is already initialized */
/* Returned by a not implemented function */
/* Returned when a given interface is not supported. */
/* Returned when a function aborts */
/* Returned when a function fails */
/* Returned when an unexpected error occurs */
/* Returned when a memory allocation fails */
/* Returned when an illegal value is passed */
/* Returned when a class doesn't allow aggregation */
/* Returned when an operation can't complete due to an unavailable resource */
/* Returned when a class is not registered */
/* Returned when a class cannot be registered, but may be tried again later */
/* Returned when a dynamically loaded factory couldn't be found */
/* Returned when a factory doesn't support signatures */
#define NS_ERROR_FACTORY_NO_SIGNATURE_SUPPORT \
(NS_ERROR_BASE + 0x101)
/* Returned when a factory already is registered */
/**
* An "interface id" which can be used to uniquely identify a given
* interface.
* A "unique identifier". This is modeled after OSF DCE UUIDs.
*/
struct nsID {
};
struct nsISupports; /* forward declaration */
struct nsIStackFrame; /* forward declaration */
struct nsIException; /* forward declaration */
/**
* IID for the nsISupports interface
* {00000000-0000-0000-c000-000000000046}
*
* To maintain binary compatibility with COM's IUnknown, we define the IID
* of nsISupports to be the same as that of COM's IUnknown.
*/
#define NS_ISUPPORTS_IID \
{ 0x00000000, 0x0000, 0x0000, \
{0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46} }
/**
* Reference count values
*
* This is the return type for AddRef() and Release() in nsISupports.
* IUnknown of COM returns an unsigned long from equivalent functions.
* The following ifdef exists to maintain binary compatibility with
* IUnknown.
*/
/**
* Basic component object model interface. Objects which implement
* this interface support runtime interface discovery (QueryInterface)
* modelled after the win32 IUnknown API.
*/
struct nsISupports_vtbl {
/**
* @name Methods
*/
/**
* A run time mechanism for interface discovery.
* @param aIID [in] A requested interface IID
* @param aInstancePtr [out] A pointer to an interface pointer to
* receive the result.
* @return NS_OK if the interface is supported by the associated
* instance, NS_NOINTERFACE if it is not.
* NS_ERROR_INVALID_POINTER if aInstancePtr is NULL.
*/
/**
* Increases the reference count for this interface.
* The associated instance will not be deleted unless
* the reference count is returned to zero.
*
* @return The resulting reference count.
*/
/**
* Decreases the reference count for this interface.
* Generally, if the reference count returns to zero,
* the associated instance is deleted.
*
* @return The resulting reference count.
*/
};
struct nsISupports {
};
/* starting interface: nsIException */
#define NS_IEXCEPTION_IID \
{0xf3a8d3b4, 0xc424, 0x4edc, \
{ 0x8b, 0xf6, 0x89, 0x74, 0xc9, 0x83, 0xba, 0x78 }}
struct nsIException_vtbl {
/* Methods from the Class nsISupports */
/* readonly attribute string message; */
/* readonly attribute nsresult (*result; */
/* readonly attribute string name; */
/* readonly attribute string filename; */
/* readonly attribute PRUint32 lineNumber; */
/* readonly attribute PRUint32 columnNumber; */
/* readonly attribute nsIStackFrame location; */
/* readonly attribute nsIException inner; */
/* readonly attribute nsISupports data; */
/* string toString (); */
};
struct nsIException {
};
/* starting interface: nsIStackFrame */
#define NS_ISTACKFRAME_IID \
{0x91d82105, 0x7c62, 0x4f8b, \
{ 0x97, 0x79, 0x15, 0x42, 0x77, 0xc0, 0xee, 0x90 }}
struct nsIStackFrame_vtbl {
/* Methods from the Class nsISupports */
/* readonly attribute PRUint32 language; */
/* readonly attribute string languageName; */
/* readonly attribute string filename; */
/* readonly attribute string name; */
/* readonly attribute PRInt32 lineNumber; */
/* readonly attribute string sourceLine; */
/* readonly attribute nsIStackFrame caller; */
/* string toString (); */
};
struct nsIStackFrame {
};
/* starting interface: nsIEventTarget */
#define NS_IEVENTTARGET_IID \
{0xea99ad5b, 0xcc67, 0x4efb, \
{ 0x97, 0xc9, 0x2e, 0xf6, 0x20, 0xa5, 0x9f, 0x2a }}
struct nsIEventTarget;
struct nsIEventTarget_vtbl {
};
struct nsIEventTarget {
};
/* starting interface: nsIEventQueue */
#define NS_IEVENTQUEUE_IID \
{0x176afb41, 0x00a4, 0x11d3, \
{ 0x9f, 0x2a, 0x00, 0x40, 0x05, 0x53, 0xee, 0xf0 }}
struct nsIEventQueue;
struct nsIEventQueue_vtbl {
nsresult (*InitEvent)(nsIEventQueue *pThis, PLEvent * aEvent, void * owner, PLHandleEventProc handler, PLDestroyEventProc destructor);
};
struct nsIEventQueue {
};
struct IVirtualBoxErrorInfo;
struct IDHCPServer;
struct IVirtualBox;
struct IVFSExplorer;
struct IAppliance;
struct IVirtualSystemDescription;
struct IInternalMachineControl;
struct IBIOSSettings;
struct IPCIAddress;
struct IPCIDeviceAttachment;
struct IMachine;
struct IVRDEServerInfo;
struct IConsole;
struct IHostNetworkInterface;
struct IHost;
struct ISystemProperties;
struct IGuestOSType;
struct IAdditionsFacility;
struct IGuestSession;
struct IProcess;
struct IGuestProcess;
struct IDirectory;
struct IGuestDirectory;
struct IFile;
struct IGuestFile;
struct IFsObjInfo;
struct IGuestFsObjInfo;
struct IGuest;
struct IProgress;
struct ISnapshot;
struct IMediumAttachment;
struct IMedium;
struct IMediumFormat;
struct IKeyboard;
struct IMouse;
struct IFramebuffer;
struct IFramebufferOverlay;
struct IDisplay;
struct INetworkAdapter;
struct ISerialPort;
struct IParallelPort;
struct IMachineDebugger;
struct IUSBController;
struct IUSBDevice;
struct IUSBDeviceFilter;
struct IHostUSBDevice;
struct IHostUSBDeviceFilter;
struct IAudioAdapter;
struct IVRDEServer;
struct ISharedFolder;
struct IInternalSessionControl;
struct ISession;
struct IStorageController;
struct IManagedObjectRef;
struct IWebsessionManager;
struct IPerformanceMetric;
struct IPerformanceCollector;
struct INATEngine;
struct IExtPackPlugIn;
struct IExtPackBase;
struct IExtPack;
struct IExtPackFile;
struct IExtPackManager;
struct IBandwidthGroup;
struct IBandwidthControl;
struct IVirtualBoxClient;
struct IEventSource;
struct IEventListener;
struct IEvent;
struct IReusableEvent;
struct IMachineEvent;
struct IMachineStateChangedEvent;
struct IMachineDataChangedEvent;
struct IMediumRegisteredEvent;
struct IMachineRegisteredEvent;
struct ISessionStateChangedEvent;
struct IGuestPropertyChangedEvent;
struct ISnapshotEvent;
struct ISnapshotTakenEvent;
struct ISnapshotDeletedEvent;
struct ISnapshotChangedEvent;
struct IMousePointerShapeChangedEvent;
struct IMouseCapabilityChangedEvent;
struct IKeyboardLedsChangedEvent;
struct IStateChangedEvent;
struct IAdditionsStateChangedEvent;
struct INetworkAdapterChangedEvent;
struct ISerialPortChangedEvent;
struct IParallelPortChangedEvent;
struct IStorageControllerChangedEvent;
struct IMediumChangedEvent;
struct IClipboardModeChangedEvent;
struct IDragAndDropModeChangedEvent;
struct ICPUChangedEvent;
struct ICPUExecutionCapChangedEvent;
struct IGuestKeyboardEvent;
struct IGuestMouseEvent;
struct IVRDEServerChangedEvent;
struct IVRDEServerInfoChangedEvent;
struct IUSBControllerChangedEvent;
struct IUSBDeviceStateChangedEvent;
struct ISharedFolderChangedEvent;
struct IRuntimeErrorEvent;
struct IEventSourceChangedEvent;
struct IExtraDataChangedEvent;
struct IVetoEvent;
struct IExtraDataCanChangeEvent;
struct ICanShowWindowEvent;
struct IShowWindowEvent;
struct INATRedirectEvent;
struct IHostPCIDevicePlugEvent;
struct IVBoxSVCAvailabilityChangedEvent;
struct IBandwidthGroupChangedEvent;
struct IGuestMonitorChangedEvent;
struct IStorageDeviceChangedEvent;
/* Start of enum SettingsVersion Declaration */
#define SETTINGSVERSION_IID { \
0x52bd6f5f, 0x1adb, 0x4493, \
{ 0x97, 0x5d, 0x58, 0x1a, 0x9c, 0x4b, 0x80, 0x3f } \
}
enum SettingsVersion
{
SettingsVersion_Null = 0,
};
/* End of enum SettingsVersion Declaration */
/* Start of enum AccessMode Declaration */
#define ACCESSMODE_IID { \
0x1da0007c, 0xddf7, 0x4be8, \
{ 0xbc, 0xac, 0xd8, 0x4a, 0x15, 0x58, 0x78, 0x5f } \
}
enum AccessMode
{
};
/* End of enum AccessMode Declaration */
/* Start of enum MachineState Declaration */
#define MACHINESTATE_IID { \
0xec6c6a9e, 0x113d, 0x4ff4, \
{ 0xb4, 0x4f, 0x0b, 0x69, 0xf2, 0x1c, 0x97, 0xfe } \
}
enum MachineState
{
MachineState_Null = 0,
};
/* End of enum MachineState Declaration */
/* Start of enum SessionState Declaration */
#define SESSIONSTATE_IID { \
0xcf2700c0, 0xea4b, 0x47ae, \
{ 0x97, 0x25, 0x78, 0x10, 0x11, 0x4b, 0x94, 0xd8 } \
}
enum SessionState
{
SessionState_Null = 0,
};
/* End of enum SessionState Declaration */
/* Start of enum CPUPropertyType Declaration */
#define CPUPROPERTYTYPE_IID { \
0x24d356a6, 0x2f45, 0x4abd, \
{ 0xb9, 0x77, 0x1c, 0xbe, 0x9c, 0x47, 0x01, 0xf5 } \
}
enum CPUPropertyType
{
CPUPropertyType_Null = 0,
};
/* End of enum CPUPropertyType Declaration */
/* Start of enum HWVirtExPropertyType Declaration */
#define HWVIRTEXPROPERTYTYPE_IID { \
0xce81dfdd, 0xd2b8, 0x4a90, \
{ 0xbb, 0xea, 0x40, 0xee, 0x8b, 0x7f, 0xfc, 0xee } \
}
enum HWVirtExPropertyType
{
};
/* End of enum HWVirtExPropertyType Declaration */
/* Start of enum FaultToleranceState Declaration */
#define FAULTTOLERANCESTATE_IID { \
0x5124f7ec, 0x6b67, 0x493c, \
{ 0x9d, 0xee, 0xee, 0x45, 0xa4, 0x41, 0x14, 0xe1 } \
}
enum FaultToleranceState
{
};
/* End of enum FaultToleranceState Declaration */
/* Start of enum LockType Declaration */
#define LOCKTYPE_IID { \
0x168a6a8e, 0x12fd, 0x4878, \
{ 0xa1, 0xf9, 0x38, 0xa7, 0x50, 0xa5, 0x60, 0x89 } \
}
enum LockType
{
};
/* End of enum LockType Declaration */
/* Start of enum SessionType Declaration */
#define SESSIONTYPE_IID { \
0xA13C02CB, 0x0C2C, 0x421E, \
{ 0x83, 0x17, 0xAC, 0x0E, 0x8A, 0xAA, 0x15, 0x3A } \
}
enum SessionType
{
SessionType_Null = 0,
};
/* End of enum SessionType Declaration */
/* Start of enum DeviceType Declaration */
#define DEVICETYPE_IID { \
0x6d9420f7, 0x0b56, 0x4636, \
{ 0x99, 0xf9, 0x73, 0x46, 0xf1, 0xb0, 0x1e, 0x57 } \
}
enum DeviceType
{
DeviceType_Null = 0,
};
/* End of enum DeviceType Declaration */
/* Start of enum DeviceActivity Declaration */
#define DEVICEACTIVITY_IID { \
0x6FC8AEAA, 0x130A, 0x4eb5, \
{ 0x89, 0x54, 0x3F, 0x92, 0x14, 0x22, 0xD7, 0x07 } \
}
enum DeviceActivity
{
DeviceActivity_Null = 0,
};
/* End of enum DeviceActivity Declaration */
/* Start of enum ClipboardMode Declaration */
#define CLIPBOARDMODE_IID { \
0x33364716, 0x4008, 0x4701, \
{ 0x8f, 0x14, 0xbe, 0x0f, 0xa3, 0xd6, 0x29, 0x50 } \
}
enum ClipboardMode
{
};
/* End of enum ClipboardMode Declaration */
/* Start of enum DragAndDropMode Declaration */
#define DRAGANDDROPMODE_IID { \
0xb618ea0e, 0xb6fb, 0x4f8d, \
{ 0x97, 0xf7, 0x5e, 0x23, 0x7e, 0x49, 0xb5, 0x47 } \
}
enum DragAndDropMode
{
};
/* End of enum DragAndDropMode Declaration */
/* Start of enum Scope Declaration */
#define SCOPE_IID { \
0x7c91096e, 0x499e, 0x4eca, \
{ 0x9f, 0x9b, 0x90, 0x01, 0x43, 0x8d, 0x78, 0x55 } \
}
enum Scope
{
Scope_Global = 0,
};
/* End of enum Scope Declaration */
/* Start of enum BIOSBootMenuMode Declaration */
#define BIOSBOOTMENUMODE_IID { \
0xae4fb9f7, 0x29d2, 0x45b4, \
{ 0xb2, 0xc7, 0xd5, 0x79, 0x60, 0x31, 0x35, 0xd5 } \
}
enum BIOSBootMenuMode
{
};
/* End of enum BIOSBootMenuMode Declaration */
/* Start of enum ProcessorFeature Declaration */
#define PROCESSORFEATURE_IID { \
0x64c38e6b, 0x8bcf, 0x45ad, \
{ 0xac, 0x03, 0x9b, 0x40, 0x62, 0x87, 0xc5, 0xbf } \
}
enum ProcessorFeature
{
};
/* End of enum ProcessorFeature Declaration */
/* Start of enum FirmwareType Declaration */
#define FIRMWARETYPE_IID { \
0xb903f264, 0xc230, 0x483e, \
{ 0xac, 0x74, 0x2b, 0x37, 0xce, 0x60, 0xd3, 0x71 } \
}
enum FirmwareType
{
};
/* End of enum FirmwareType Declaration */
/* Start of enum PointingHIDType Declaration */
#define POINTINGHIDTYPE_IID { \
0xe44b2f7b, 0x72ba, 0x44fb, \
{ 0x9e, 0x53, 0x21, 0x86, 0x01, 0x4f, 0x0d, 0x17 } \
}
enum PointingHIDType
{
};
/* End of enum PointingHIDType Declaration */
/* Start of enum KeyboardHIDType Declaration */
#define KEYBOARDHIDTYPE_IID { \
0x383e43d7, 0x5c7c, 0x4ec8, \
{ 0x9c, 0xb8, 0xed, 0xa1, 0xbc, 0xcd, 0x66, 0x99 } \
}
enum KeyboardHIDType
{
};
/* End of enum KeyboardHIDType Declaration */
/* Start of enum VFSType Declaration */
#define VFSTYPE_IID { \
0x813999ba, 0xb949, 0x48a8, \
{ 0x92, 0x30, 0xaa, 0xdc, 0x62, 0x85, 0xe2, 0xf2 } \
}
enum VFSType
{
};
/* End of enum VFSType Declaration */
/* Start of enum VFSFileType Declaration */
#define VFSFILETYPE_IID { \
0x714333cd, 0x44e2, 0x415f, \
{ 0xa2, 0x45, 0xd3, 0x78, 0xfa, 0x9b, 0x12, 0x42 } \
}
enum VFSFileType
{
};
/* End of enum VFSFileType Declaration */
/* Start of enum ImportOptions Declaration */
#define IMPORTOPTIONS_IID { \
0x0a981523, 0x3b20, 0x4004, \
{ 0x8e, 0xe3, 0xdf, 0xd3, 0x22, 0x20, 0x2a, 0xce } \
}
enum ImportOptions
{
};
/* End of enum ImportOptions Declaration */
/* Start of enum VirtualSystemDescriptionType Declaration */
#define VIRTUALSYSTEMDESCRIPTIONTYPE_IID { \
0x303c0900, 0xa746, 0x4612, \
{ 0x8c, 0x67, 0x79, 0x00, 0x3e, 0x91, 0xf4, 0x59 } \
}
{
};
/* End of enum VirtualSystemDescriptionType Declaration */
/* Start of enum VirtualSystemDescriptionValueType Declaration */
#define VIRTUALSYSTEMDESCRIPTIONVALUETYPE_IID { \
0x56d9403f, 0x3425, 0x4118, \
{ 0x99, 0x19, 0x36, 0xf2, 0xa9, 0xb8, 0xc7, 0x7c } \
}
{
};
/* End of enum VirtualSystemDescriptionValueType Declaration */
/* Start of enum CleanupMode Declaration */
#define CLEANUPMODE_IID { \
0x67897c50, 0x7cca, 0x47a9, \
{ 0x83, 0xf6, 0xce, 0x8f, 0xd8, 0xeb, 0x54, 0x41 } \
}
enum CleanupMode
{
};
/* End of enum CleanupMode Declaration */
/* Start of enum CloneMode Declaration */
#define CLONEMODE_IID { \
0xA7A159FE, 0x5096, 0x4B8D, \
{ 0x8C, 0x3C, 0xD0, 0x33, 0xCB, 0x0B, 0x35, 0xA8 } \
}
enum CloneMode
{
};
/* End of enum CloneMode Declaration */
/* Start of enum CloneOptions Declaration */
#define CLONEOPTIONS_IID { \
0x22243f8e, 0x96ab, 0x497c, \
{ 0x8c, 0xf0, 0xf4, 0x0a, 0x56, 0x6c, 0x63, 0x0b } \
}
enum CloneOptions
{
};
/* End of enum CloneOptions Declaration */
/* Start of enum AutostopType Declaration */
#define AUTOSTOPTYPE_IID { \
0x6bb96740, 0xcf34, 0x470d, \
{ 0xaa, 0xb2, 0x2c, 0xd4, 0x8e, 0xa2, 0xe1, 0x0e } \
}
enum AutostopType
{
};
/* End of enum AutostopType Declaration */
/* Start of enum HostNetworkInterfaceMediumType Declaration */
#define HOSTNETWORKINTERFACEMEDIUMTYPE_IID { \
0x1aa54aaf, 0x2497, 0x45a2, \
{ 0xbf, 0xb1, 0x8e, 0xb2, 0x25, 0xe9, 0x3d, 0x5b } \
}
{
};
/* End of enum HostNetworkInterfaceMediumType Declaration */
/* Start of enum HostNetworkInterfaceStatus Declaration */
#define HOSTNETWORKINTERFACESTATUS_IID { \
0xCC474A69, 0x2710, 0x434B, \
{ 0x8D, 0x99, 0xC3, 0x8E, 0x5D, 0x5A, 0x6F, 0x41 } \
}
{
};
/* End of enum HostNetworkInterfaceStatus Declaration */
/* Start of enum HostNetworkInterfaceType Declaration */
#define HOSTNETWORKINTERFACETYPE_IID { \
0x67431b00, 0x9946, 0x48a2, \
{ 0xbc, 0x02, 0xb2, 0x5c, 0x59, 0x19, 0xf4, 0xf3 } \
}
{
};
/* End of enum HostNetworkInterfaceType Declaration */
/* Start of enum AdditionsFacilityType Declaration */
#define ADDITIONSFACILITYTYPE_IID { \
0x98f7f957, 0x89fb, 0x49b6, \
{ 0xa3, 0xb1, 0x31, 0xe3, 0x28, 0x5e, 0xb1, 0xd8 } \
}
{
};
/* End of enum AdditionsFacilityType Declaration */
/* Start of enum AdditionsFacilityClass Declaration */
#define ADDITIONSFACILITYCLASS_IID { \
0x446451b2, 0xc88d, 0x4e5d, \
{ 0x84, 0xc9, 0x91, 0xbc, 0x7f, 0x53, 0x3f, 0x5f } \
}
{
};
/* End of enum AdditionsFacilityClass Declaration */
/* Start of enum AdditionsFacilityStatus Declaration */
#define ADDITIONSFACILITYSTATUS_IID { \
0xce06f9e1, 0x394e, 0x4fe9, \
{ 0x93, 0x68, 0x5a, 0x88, 0xc5, 0x67, 0xdb, 0xde } \
}
{
};
/* End of enum AdditionsFacilityStatus Declaration */
/* Start of enum AdditionsRunLevelType Declaration */
#define ADDITIONSRUNLEVELTYPE_IID { \
0xa25417ee, 0xa9dd, 0x4f5b, \
{ 0xb0, 0xdc, 0x37, 0x78, 0x60, 0x08, 0x77, 0x54 } \
}
{
};
/* End of enum AdditionsRunLevelType Declaration */
/* Start of enum AdditionsUpdateFlag Declaration */
#define ADDITIONSUPDATEFLAG_IID { \
0x726a818d, 0x18d6, 0x4389, \
{ 0x94, 0xe8, 0x3e, 0x9e, 0x68, 0x26, 0x17, 0x1a } \
}
enum AdditionsUpdateFlag
{
};
/* End of enum AdditionsUpdateFlag Declaration */
/* Start of enum FileSeekType Declaration */
#define FILESEEKTYPE_IID { \
0x1b73f4f3, 0x3515, 0x4073, \
{ 0xa5, 0x06, 0x76, 0x87, 0x8d, 0x9e, 0x25, 0x41 } \
}
enum FileSeekType
{
FileSeekType_Set = 0,
};
/* End of enum FileSeekType Declaration */
/* Start of enum ProcessInputFlag Declaration */
#define PROCESSINPUTFLAG_IID { \
0x5d38c1dd, 0x2604, 0x4ddf, \
{ 0x92, 0xe5, 0x0c, 0x0c, 0xdd, 0x3b, 0xdb, 0xd5 } \
}
enum ProcessInputFlag
{
};
/* End of enum ProcessInputFlag Declaration */
/* Start of enum ProcessOutputFlag Declaration */
#define PROCESSOUTPUTFLAG_IID { \
0x9979e85a, 0x52bb, 0x40b7, \
{ 0x87, 0x0c, 0x57, 0x11, 0x5e, 0x27, 0xe0, 0xf1 } \
}
enum ProcessOutputFlag
{
};
/* End of enum ProcessOutputFlag Declaration */
/* Start of enum ProcessWaitForFlag Declaration */
#define PROCESSWAITFORFLAG_IID { \
0x23b550c7, 0x78e1, 0x437e, \
{ 0x98, 0xf0, 0x65, 0xfd, 0x97, 0x57, 0xbc, 0xd2 } \
}
enum ProcessWaitForFlag
{
};
/* End of enum ProcessWaitForFlag Declaration */
/* Start of enum ProcessWaitResult Declaration */
#define PROCESSWAITRESULT_IID { \
0x40719cbe, 0xf192, 0x4fe9, \
{ 0xa2, 0x31, 0x66, 0x97, 0xb3, 0xc8, 0xe2, 0xb4 } \
}
enum ProcessWaitResult
{
};
/* End of enum ProcessWaitResult Declaration */
/* Start of enum CopyFileFlag Declaration */
#define COPYFILEFLAG_IID { \
0x23f79fdf, 0x738a, 0x493d, \
{ 0xb8, 0x0b, 0x42, 0xd6, 0x07, 0xc9, 0xb9, 0x16 } \
}
enum CopyFileFlag
{
CopyFileFlag_None = 0,
};
/* End of enum CopyFileFlag Declaration */
/* Start of enum DirectoryCreateFlag Declaration */
#define DIRECTORYCREATEFLAG_IID { \
0xbd721b0e, 0xced5, 0x4f79, \
{ 0xb3, 0x68, 0x24, 0x98, 0x97, 0xc3, 0x2a, 0x36 } \
}
enum DirectoryCreateFlag
{
};
/* End of enum DirectoryCreateFlag Declaration */
/* Start of enum DirectoryRemoveRecFlag Declaration */
#define DIRECTORYREMOVERECFLAG_IID { \
0x455aabf0, 0x7692, 0x48f6, \
{ 0x90, 0x61, 0xf2, 0x15, 0x79, 0xb6, 0x57, 0x69 } \
}
{
};
/* End of enum DirectoryRemoveRecFlag Declaration */
/* Start of enum PathRenameFlag Declaration */
#define PATHRENAMEFLAG_IID { \
0xf3baa09f, 0xc758, 0x453d, \
{ 0xb9, 0x1c, 0xc7, 0x78, 0x7d, 0x76, 0x35, 0x1d } \
}
enum PathRenameFlag
{
PathRenameFlag_None = 0,
};
/* End of enum PathRenameFlag Declaration */
/* Start of enum ProcessCreateFlag Declaration */
#define PROCESSCREATEFLAG_IID { \
0x35192799, 0xbfde, 0x405d, \
{ 0x9b, 0xea, 0xc7, 0x35, 0xab, 0x99, 0x98, 0xe4 } \
}
enum ProcessCreateFlag
{
};
/* End of enum ProcessCreateFlag Declaration */
/* Start of enum ProcessPriority Declaration */
#define PROCESSPRIORITY_IID { \
0xee8cac50, 0xe232, 0x49fe, \
{ 0x80, 0x6b, 0xd1, 0x21, 0x4d, 0x9c, 0x2e, 0x49 } \
}
enum ProcessPriority
{
};
/* End of enum ProcessPriority Declaration */
/* Start of enum SymlinkType Declaration */
#define SYMLINKTYPE_IID { \
0x37794668, 0xf8f1, 0x4714, \
{ 0x98, 0xa5, 0x6f, 0x8f, 0xa2, 0xed, 0x01, 0x18 } \
}
enum SymlinkType
{
SymlinkType_Unknown = 0,
};
/* End of enum SymlinkType Declaration */
/* Start of enum SymlinkReadFlag Declaration */
#define SYMLINKREADFLAG_IID { \
0xb7fe2b9d, 0x790e, 0x4b25, \
{ 0x8a, 0xdf, 0x1c, 0xa3, 0x30, 0x26, 0x93, 0x1f } \
}
enum SymlinkReadFlag
{
SymlinkReadFlag_None = 0,
};
/* End of enum SymlinkReadFlag Declaration */
/* Start of enum ProcessStatus Declaration */
#define PROCESSSTATUS_IID { \
0x4d52368f, 0x5b48, 0x4bfe, \
{ 0xb4, 0x86, 0xac, 0xf8, 0x91, 0x39, 0xb5, 0x2f } \
}
enum ProcessStatus
{
};
/* End of enum ProcessStatus Declaration */
/* Start of enum FsObjType Declaration */
#define FSOBJTYPE_IID { \
0xa1ed437c, 0xb3c3, 0x4ca2, \
{ 0xb1, 0x9c, 0x42, 0x39, 0xd6, 0x58, 0xd5, 0xe8 } \
}
enum FsObjType
{
FsObjType_Undefined = 0,
};
/* End of enum FsObjType Declaration */
/* Start of enum DragAndDropAction Declaration */
#define DRAGANDDROPACTION_IID { \
0x47f3b162, 0xc107, 0x4fcd, \
{ 0xbf, 0xa7, 0x54, 0xb8, 0x13, 0x5c, 0x44, 0x1e } \
}
enum DragAndDropAction
{
};
/* End of enum DragAndDropAction Declaration */
/* Start of enum DirectoryOpenFlag Declaration */
#define DIRECTORYOPENFLAG_IID { \
0x5138837a, 0x8fd2, 0x4194, \
{ 0xa1, 0xb0, 0x08, 0xf7, 0xbc, 0x39, 0x49, 0xd0 } \
}
enum DirectoryOpenFlag
{
};
/* End of enum DirectoryOpenFlag Declaration */
/* Start of enum MediumState Declaration */
#define MEDIUMSTATE_IID { \
0xef41e980, 0xe012, 0x43cd, \
{ 0x9d, 0xea, 0x47, 0x9d, 0x4e, 0xf1, 0x4d, 0x13 } \
}
enum MediumState
{
};
/* End of enum MediumState Declaration */
/* Start of enum MediumType Declaration */
#define MEDIUMTYPE_IID { \
0xfe663fb5, 0xc244, 0x4e1b, \
{ 0x9d, 0x81, 0xc6, 0x28, 0xb4, 0x17, 0xdd, 0x04 } \
}
enum MediumType
{
MediumType_Normal = 0,
};
/* End of enum MediumType Declaration */
/* Start of enum MediumVariant Declaration */
#define MEDIUMVARIANT_IID { \
0x80685b6b, 0xe42f, 0x497d, \
{ 0x82, 0x71, 0xe7, 0x7b, 0xf3, 0xc6, 0x1a, 0xda } \
}
enum MediumVariant
{
};
/* End of enum MediumVariant Declaration */
/* Start of enum DataType Declaration */
#define DATATYPE_IID { \
0xd90ea51e, 0xa3f1, 0x4a01, \
{ 0xbe, 0xb1, 0xc1, 0x72, 0x3c, 0x0d, 0x3b, 0xa7 } \
}
enum DataType
{
DataType_Int32 = 0,
};
/* End of enum DataType Declaration */
/* Start of enum DataFlags Declaration */
#define DATAFLAGS_IID { \
0x86884dcf, 0x1d6b, 0x4f1b, \
{ 0xb4, 0xbf, 0xf5, 0xaa, 0x44, 0x95, 0x9d, 0x60 } \
}
enum DataFlags
{
};
/* End of enum DataFlags Declaration */
/* Start of enum MediumFormatCapabilities Declaration */
#define MEDIUMFORMATCAPABILITIES_IID { \
0x7342ba79, 0x7ce0, 0x4d94, \
{ 0x8f, 0x86, 0x5e, 0xd5, 0xa1, 0x85, 0xd9, 0xbd } \
}
{
};
/* End of enum MediumFormatCapabilities Declaration */
/* Start of enum MouseButtonState Declaration */
#define MOUSEBUTTONSTATE_IID { \
0x9ee094b8, 0xb28a, 0x4d56, \
{ 0xa1, 0x66, 0x97, 0x3c, 0xb5, 0x88, 0xd7, 0xf8 } \
}
enum MouseButtonState
{
};
/* End of enum MouseButtonState Declaration */
/* Start of enum FramebufferPixelFormat Declaration */
#define FRAMEBUFFERPIXELFORMAT_IID { \
0x7acfd5ed, 0x29e3, 0x45e3, \
{ 0x81, 0x36, 0x73, 0xc9, 0x22, 0x4f, 0x3d, 0x2d } \
}
{
};
/* End of enum FramebufferPixelFormat Declaration */
/* Start of enum NetworkAttachmentType Declaration */
#define NETWORKATTACHMENTTYPE_IID { \
0x2ac4bc71, 0x6b82, 0x417a, \
{ 0xac, 0xd1, 0xf7, 0x42, 0x6d, 0x25, 0x70, 0xd6 } \
}
{
};
/* End of enum NetworkAttachmentType Declaration */
/* Start of enum NetworkAdapterType Declaration */
#define NETWORKADAPTERTYPE_IID { \
0x3c2281e4, 0xd952, 0x4e87, \
{ 0x8c, 0x7d, 0x24, 0x37, 0x9c, 0xb6, 0xa8, 0x1c } \
}
enum NetworkAdapterType
{
};
/* End of enum NetworkAdapterType Declaration */
/* Start of enum NetworkAdapterPromiscModePolicy Declaration */
#define NETWORKADAPTERPROMISCMODEPOLICY_IID { \
0xc963768a, 0x376f, 0x4c85, \
{ 0x8d, 0x84, 0xd8, 0xce, 0xd4, 0xb7, 0x26, 0x9e } \
}
{
};
/* End of enum NetworkAdapterPromiscModePolicy Declaration */
/* Start of enum PortMode Declaration */
#define PORTMODE_IID { \
0x533b5fe3, 0x0185, 0x4197, \
{ 0x86, 0xa7, 0x17, 0xe3, 0x7d, 0xd3, 0x9d, 0x76 } \
}
enum PortMode
{
};
/* End of enum PortMode Declaration */
/* Start of enum USBDeviceState Declaration */
#define USBDEVICESTATE_IID { \
0xb99a2e65, 0x67fb, 0x4882, \
{ 0x82, 0xfd, 0xf3, 0xe5, 0xe8, 0x19, 0x3a, 0xb4 } \
}
enum USBDeviceState
{
};
/* End of enum USBDeviceState Declaration */
/* Start of enum USBDeviceFilterAction Declaration */
#define USBDEVICEFILTERACTION_IID { \
0xcbc30a49, 0x2f4e, 0x43b5, \
{ 0x9d, 0xa6, 0x12, 0x13, 0x20, 0x47, 0x59, 0x33 } \
}
{
};
/* End of enum USBDeviceFilterAction Declaration */
/* Start of enum AudioDriverType Declaration */
#define AUDIODRIVERTYPE_IID { \
0x4bcc3d73, 0xc2fe, 0x40db, \
{ 0xb7, 0x2f, 0x0c, 0x2c, 0xa9, 0xd6, 0x84, 0x96 } \
}
enum AudioDriverType
{
AudioDriverType_Null = 0,
};
/* End of enum AudioDriverType Declaration */
/* Start of enum AudioControllerType Declaration */
#define AUDIOCONTROLLERTYPE_IID { \
0x7afd395c, 0x42c3, 0x444e, \
{ 0x87, 0x88, 0x3c, 0xe8, 0x02, 0x92, 0xf3, 0x6c } \
}
enum AudioControllerType
{
};
/* End of enum AudioControllerType Declaration */
/* Start of enum AuthType Declaration */
#define AUTHTYPE_IID { \
0x7eef6ef6, 0x98c2, 0x4dc2, \
{ 0xab, 0x35, 0x10, 0xd2, 0xb2, 0x92, 0x02, 0x8d } \
}
enum AuthType
{
AuthType_Null = 0,
};
/* End of enum AuthType Declaration */
/* Start of enum Reason Declaration */
#define REASON_IID { \
0xe7e8e097, 0x299d, 0x4e98, \
{ 0x8b, 0xbc, 0xc3, 0x1c, 0x2d, 0x47, 0xd0, 0xcc } \
}
enum Reason
{
Reason_Unspecified = 0,
};
/* End of enum Reason Declaration */
/* Start of enum StorageBus Declaration */
#define STORAGEBUS_IID { \
0xeee67ab3, 0x668d, 0x4ef5, \
{ 0x91, 0xe0, 0x70, 0x25, 0xfe, 0x4a, 0x0d, 0x7a } \
}
enum StorageBus
{
StorageBus_Null = 0,
};
/* End of enum StorageBus Declaration */
/* Start of enum StorageControllerType Declaration */
#define STORAGECONTROLLERTYPE_IID { \
0x8a412b8a, 0xf43e, 0x4456, \
{ 0xbd, 0x37, 0xb4, 0x74, 0xf0, 0x87, 0x9a, 0x58 } \
}
{
};
/* End of enum StorageControllerType Declaration */
/* Start of enum ChipsetType Declaration */
#define CHIPSETTYPE_IID { \
0x8b4096a8, 0xa7c3, 0x4d3b, \
{ 0xbb, 0xb1, 0x05, 0xa0, 0xa5, 0x1e, 0xc3, 0x94 } \
}
enum ChipsetType
{
ChipsetType_Null = 0,
};
/* End of enum ChipsetType Declaration */
/* Start of enum NATAliasMode Declaration */
#define NATALIASMODE_IID { \
0x67772168, 0x50d9, 0x11df, \
{ 0x96, 0x69, 0x7f, 0xb7, 0x14, 0xee, 0x4f, 0xa1 } \
}
enum NATAliasMode
{
};
/* End of enum NATAliasMode Declaration */
/* Start of enum NATProtocol Declaration */
#define NATPROTOCOL_IID { \
0xe90164be, 0xeb03, 0x11de, \
{ 0x94, 0xaf, 0xff, 0xf9, 0xb1, 0xc1, 0xb1, 0x9f } \
}
enum NATProtocol
{
NATProtocol_UDP = 0,
};
/* End of enum NATProtocol Declaration */
/* Start of enum BandwidthGroupType Declaration */
#define BANDWIDTHGROUPTYPE_IID { \
0x1d92b67d, 0xdc69, 0x4be9, \
{ 0xad, 0x4c, 0x93, 0xa0, 0x1e, 0x1e, 0x0c, 0x8e } \
}
enum BandwidthGroupType
{
};
/* End of enum BandwidthGroupType Declaration */
/* Start of enum VBoxEventType Declaration */
#define VBOXEVENTTYPE_IID { \
0x0d67e79e, 0xb7b1, 0x4919, \
{ 0xaa, 0xb3, 0xb3, 0x68, 0x66, 0x07, 0x55, 0x15 } \
}
enum VBoxEventType
{
};
/* End of enum VBoxEventType Declaration */
/* Start of enum GuestMonitorChangedEventType Declaration */
#define GUESTMONITORCHANGEDEVENTTYPE_IID { \
0xef172985, 0x7e36, 0x4297, \
{ 0x95, 0xbe, 0xe4, 0x63, 0x96, 0x96, 0x8d, 0x66 } \
}
{
};
/* End of enum GuestMonitorChangedEventType Declaration */
/* Start of struct IVirtualBoxErrorInfo Declaration */
#define IVIRTUALBOXERRORINFO_IID { \
0xf91e6e91, 0x49e1, 0x4fd2, \
{ 0xb2, 0x1e, 0x26, 0x90, 0x03, 0x35, 0x0d, 0x06 } \
}
struct IVirtualBoxErrorInfo_vtbl
{
};
struct IVirtualBoxErrorInfo
{
};
/* End of struct IVirtualBoxErrorInfo Declaration */
/* Start of struct IDHCPServer Declaration */
#define IDHCPSERVER_IID { \
0x6cfe387c, 0x74fb, 0x4ca7, \
{ 0xbf, 0xf6, 0x97, 0x3b, 0xec, 0x8a, 0xf7, 0xa3 } \
}
struct IDHCPServer_vtbl
{
);
);
};
struct IDHCPServer
{
};
/* End of struct IDHCPServer Declaration */
/* Start of struct IVirtualBox Declaration */
#define IVIRTUALBOX_IID { \
0x3b2f08eb, 0xb810, 0x4715, \
{ 0xbe, 0xe0, 0xbb, 0x06, 0xb9, 0x88, 0x0a, 0xd2 } \
}
struct IVirtualBox_vtbl
{
nsresult (*GetMachineGroups)(IVirtualBox *pThis, PRUint32 *machineGroupsSize, PRUnichar * **machineGroups);
nsresult (*GetFloppyImages)(IVirtualBox *pThis, PRUint32 *floppyImagesSize, IMedium * **floppyImages);
nsresult (*GetProgressOperations)(IVirtualBox *pThis, PRUint32 *progressOperationsSize, IProgress * **progressOperations);
nsresult (*GetGuestOSTypes)(IVirtualBox *pThis, PRUint32 *guestOSTypesSize, IGuestOSType * **guestOSTypes);
nsresult (*GetSharedFolders)(IVirtualBox *pThis, PRUint32 *sharedFoldersSize, ISharedFolder * **sharedFolders);
nsresult (*GetPerformanceCollector)(IVirtualBox *pThis, IPerformanceCollector * *performanceCollector);
nsresult (*GetDHCPServers)(IVirtualBox *pThis, PRUint32 *DHCPServersSize, IDHCPServer * **DHCPServers);
nsresult (*GetInternalNetworks)(IVirtualBox *pThis, PRUint32 *internalNetworksSize, PRUnichar * **internalNetworks);
nsresult (*GetGenericNetworkDrivers)(IVirtualBox *pThis, PRUint32 *genericNetworkDriversSize, PRUnichar * **genericNetworkDrivers);
);
);
);
);
);
);
);
IAppliance * * appliance
);
);
);
IGuestOSType * * type
);
);
);
);
);
);
);
IDHCPServer * * server
);
IDHCPServer * * server
);
);
);
};
struct IVirtualBox
{
};
/* End of struct IVirtualBox Declaration */
/* Start of struct IVFSExplorer Declaration */
#define IVFSEXPLORER_IID { \
0x003d7f92, 0xd38e, 0x487f, \
{ 0xb7, 0x90, 0x8c, 0x5e, 0x86, 0x31, 0xcb, 0x2f } \
}
struct IVFSExplorer_vtbl
{
);
);
);
);
);
);
};
struct IVFSExplorer
{
};
/* End of struct IVFSExplorer Declaration */
/* Start of struct IAppliance Declaration */
#define IAPPLIANCE_IID { \
0x3059cf9e, 0x25c7, 0x4f0b, \
{ 0x9f, 0xa5, 0x3c, 0x42, 0xe4, 0x41, 0x67, 0x0b } \
}
struct IAppliance_vtbl
{
nsresult (*GetVirtualSystemDescriptions)(IAppliance *pThis, PRUint32 *virtualSystemDescriptionsSize, IVirtualSystemDescription * **virtualSystemDescriptions);
);
);
);
);
);
};
struct IAppliance
{
};
/* End of struct IAppliance Declaration */
/* Start of struct IVirtualSystemDescription Declaration */
#define IVIRTUALSYSTEMDESCRIPTION_IID { \
0xd7525e6c, 0x531a, 0x4c51, \
{ 0x8e, 0x04, 0x41, 0x23, 0x50, 0x83, 0xa3, 0xd8 } \
}
{
PRUnichar *** aOvfValues,
PRUnichar *** aVBoxValues,
);
PRUnichar *** aOvfValues,
PRUnichar *** aVBoxValues,
);
);
PRUnichar ** aVBoxValues,
);
);
};
struct IVirtualSystemDescription
{
};
/* End of struct IVirtualSystemDescription Declaration */
/* Start of struct IInternalMachineControl Declaration */
#define IINTERNALMACHINECONTROL_IID { \
0xdca36a92, 0x703c, 0x4649, \
{ 0x98, 0xa4, 0xf4, 0x0c, 0x1e, 0xf0, 0xc3, 0x36 } \
}
struct IInternalMachineControl_vtbl
{
);
);
);
);
);
);
);
IUSBDevice * device,
);
);
);
);
);
);
);
);
);
);
);
);
);
);
);
);
);
};
struct IInternalMachineControl
{
};
/* End of struct IInternalMachineControl Declaration */
/* Start of struct IBIOSSettings Declaration */
#define IBIOSSETTINGS_IID { \
0x38b54279, 0xdc35, 0x4f5e, \
{ 0xa4, 0x31, 0x83, 0x5b, 0x86, 0x7c, 0x6b, 0x5e } \
}
struct IBIOSSettings_vtbl
{
};
struct IBIOSSettings
{
};
/* End of struct IBIOSSettings Declaration */
/* Start of struct IPCIAddress Declaration */
#define IPCIADDRESS_IID { \
0xD88B324F, 0xDB19, 0x4D3B, \
{ 0xA1, 0xA9, 0xBF, 0x5B, 0x12, 0x71, 0x99, 0xA8 } \
}
struct IPCIAddress_vtbl
{
);
);
};
struct IPCIAddress
{
};
/* End of struct IPCIAddress Declaration */
/* Start of struct IPCIDeviceAttachment Declaration */
#define IPCIDEVICEATTACHMENT_IID { \
0x91f33d6f, 0xe621, 0x4f70, \
{ 0xa7, 0x7e, 0x15, 0xf0, 0xe3, 0xc7, 0x14, 0xd5 } \
}
struct IPCIDeviceAttachment_vtbl
{
};
struct IPCIDeviceAttachment
{
};
/* End of struct IPCIDeviceAttachment Declaration */
/* Start of struct IMachine Declaration */
#define IMACHINE_IID { \
0x22781af3, 0x1c96, 0x4126, \
{ 0x9e, 0xdf, 0x67, 0xa0, 0x20, 0xe0, 0xe8, 0x58 } \
}
struct IMachine_vtbl
{
nsresult (*GetMediumAttachments)(IMachine *pThis, PRUint32 *mediumAttachmentsSize, IMediumAttachment * **mediumAttachments);
nsresult (*GetStorageControllers)(IMachine *pThis, PRUint32 *storageControllersSize, IStorageController * **storageControllers);
nsresult (*GetSharedFolders)(IMachine *pThis, PRUint32 *sharedFoldersSize, ISharedFolder * **sharedFolders);
nsresult (*GetGuestPropertyNotificationPatterns)(IMachine *pThis, PRUnichar * *guestPropertyNotificationPatterns);
nsresult (*SetGuestPropertyNotificationPatterns)(IMachine *pThis, PRUnichar * guestPropertyNotificationPatterns);
nsresult (*GetPCIDeviceAssignments)(IMachine *pThis, PRUint32 *PCIDeviceAssignmentsSize, IPCIDeviceAttachment * **PCIDeviceAssignments);
);
);
);
);
);
);
);
);
);
);
);
);
);
);
);
);
);
);
);
);
);
);
);
);
);
);
ISerialPort * * port
);
IParallelPort * * port
);
);
);
);
);
);
);
);
);
);
);
);
);
);
);
);
);
);
);
);
);
);
);
);
);
);
);
);
);
);
);
);
);
);
);
);
);
);
};
struct IMachine
{
};
/* End of struct IMachine Declaration */
/* Start of struct IVRDEServerInfo Declaration */
#define IVRDESERVERINFO_IID { \
0x714434a1, 0x58c3, 0x4aab, \
{ 0x90, 0x49, 0x76, 0x52, 0xc5, 0xdf, 0x11, 0x3b } \
}
struct IVRDEServerInfo_vtbl
{
};
struct IVRDEServerInfo
{
};
/* End of struct IVRDEServerInfo Declaration */
/* Start of struct IConsole Declaration */
#define ICONSOLE_IID { \
0xdb7ab4ca, 0x2a3f, 0x4183, \
{ 0x92, 0x43, 0xc1, 0x20, 0x8d, 0xa9, 0x23, 0x92 } \
}
struct IConsole_vtbl
{
nsresult (*GetRemoteUSBDevices)(IConsole *pThis, PRUint32 *remoteUSBDevicesSize, IHostUSBDevice * **remoteUSBDevices);
nsresult (*GetSharedFolders)(IConsole *pThis, PRUint32 *sharedFoldersSize, ISharedFolder * **sharedFolders);
nsresult (*GetAttachedPCIDevices)(IConsole *pThis, PRUint32 *attachedPCIDevicesSize, IPCIDeviceAttachment * **attachedPCIDevices);
);
);
);
);
);
);
);
);
);
);
IUSBDevice * * device
);
IUSBDevice * * device
);
IUSBDevice * * device
);
);
);
);
);
);
);
);
);
};
struct IConsole
{
};
/* End of struct IConsole Declaration */
/* Start of struct IHostNetworkInterface Declaration */
#define IHOSTNETWORKINTERFACE_IID { \
0x87a4153d, 0x6889, 0x4dd6, \
{ 0x96, 0x54, 0x2e, 0x9f, 0xf0, 0xae, 0x8d, 0xec } \
}
struct IHostNetworkInterface_vtbl
{
nsresult (*GetIPV6NetworkMaskPrefixLength)(IHostNetworkInterface *pThis, PRUint32 *IPV6NetworkMaskPrefixLength);
);
);
};
struct IHostNetworkInterface
{
};
/* End of struct IHostNetworkInterface Declaration */
/* Start of struct IHost Declaration */
#define IHOST_IID { \
0x30678943, 0x32df, 0x4830, \
{ 0xb4, 0x13, 0x93, 0x1b, 0x25, 0xac, 0x86, 0xa0 } \
}
struct IHost_vtbl
{
nsresult (*GetUSBDeviceFilters)(IHost *pThis, PRUint32 *USBDeviceFiltersSize, IHostUSBDeviceFilter * **USBDeviceFilters);
nsresult (*GetNetworkInterfaces)(IHost *pThis, PRUint32 *networkInterfacesSize, IHostNetworkInterface * **networkInterfaces);
);
);
PRUnichar * * description
);
);
);
);
);
);
);
);
);
);
);
);
IHostUSBDevice * * device
);
IHostUSBDevice * * device
);
);
};
struct IHost
{
};
/* End of struct IHost Declaration */
/* Start of struct ISystemProperties Declaration */
#define ISYSTEMPROPERTIES_IID { \
0x1d7aca29, 0x97f0, 0x4287, \
{ 0x98, 0x74, 0xa6, 0x0e, 0xc4, 0xf8, 0x0e, 0xa6 } \
}
struct ISystemProperties_vtbl
{
nsresult (*GetMediumFormats)(ISystemProperties *pThis, PRUint32 *mediumFormatsSize, IMediumFormat * **mediumFormats);
nsresult (*GetFreeDiskSpacePercentWarning)(ISystemProperties *pThis, PRUint32 *freeDiskSpacePercentWarning);
nsresult (*SetFreeDiskSpacePercentWarning)(ISystemProperties *pThis, PRUint32 freeDiskSpacePercentWarning);
nsresult (*GetFreeDiskSpacePercentError)(ISystemProperties *pThis, PRUint32 *freeDiskSpacePercentError);
nsresult (*SetFreeDiskSpacePercentError)(ISystemProperties *pThis, PRUint32 freeDiskSpacePercentError);
);
);
);
);
);
);
);
);
};
struct ISystemProperties
{
};
/* End of struct ISystemProperties Declaration */
/* Start of struct IGuestOSType Declaration */
#define IGUESTOSTYPE_IID { \
0x6d968f9a, 0x858b, 0x4c50, \
{ 0xbf, 0x17, 0x24, 0x1f, 0x06, 0x9e, 0x94, 0xc2 } \
}
struct IGuestOSType_vtbl
{
nsresult (*GetRecommended2DVideoAcceleration)(IGuestOSType *pThis, PRBool *recommended2DVideoAcceleration);
nsresult (*GetRecommendedDVDStorageController)(IGuestOSType *pThis, PRUint32 *recommendedDVDStorageController);
nsresult (*GetRecommendedHDStorageController)(IGuestOSType *pThis, PRUint32 *recommendedHDStorageController);
nsresult (*GetRecommendedAudioController)(IGuestOSType *pThis, PRUint32 *recommendedAudioController);
};
struct IGuestOSType
{
};
/* End of struct IGuestOSType Declaration */
/* Start of struct IAdditionsFacility Declaration */
#define IADDITIONSFACILITY_IID { \
0x54992946, 0x6af1, 0x4e49, \
{ 0x98, 0xec, 0x58, 0xb5, 0x58, 0xb7, 0x29, 0x1e } \
}
struct IAdditionsFacility_vtbl
{
};
struct IAdditionsFacility
{
};
/* End of struct IAdditionsFacility Declaration */
/* Start of struct IGuestSession Declaration */
#define IGUESTSESSION_IID { \
0x57eb82a8, 0x822b, 0x42c1, \
{ 0x9d, 0x1c, 0x5c, 0x54, 0xbc, 0x3d, 0x32, 0x50 } \
}
struct IGuestSession_vtbl
{
nsresult (*GetEnvironment)(IGuestSession *pThis, PRUint32 *environmentSize, PRUnichar * **environment);
nsresult (*SetEnvironment)(IGuestSession *pThis, PRUint32 environmentSize, PRUnichar * *environment);
nsresult (*GetProcesses)(IGuestSession *pThis, PRUint32 *processesSize, IGuestProcess * **processes);
nsresult (*GetDirectories)(IGuestSession *pThis, PRUint32 *directoriesSize, IGuestDirectory * **directories);
);
);
);
);
);
);
IGuestFsObjInfo * * info
);
);
);
);
);
);
);
);
IGuestFile * * file
);
);
);
IGuestFile * * file
);
IGuestFsObjInfo * * info
);
);
);
);
PRUnichar ** environment,
);
PRUnichar ** environment,
);
);
);
);
);
);
);
};
struct IGuestSession
{
};
/* End of struct IGuestSession Declaration */
/* Start of struct IProcess Declaration */
#define IPROCESS_IID { \
0x08864d56, 0x96ab, 0x418b, \
{ 0xad, 0xbc, 0x5a, 0x67, 0x95, 0x32, 0xae, 0xb0 } \
}
struct IProcess_vtbl
{
);
);
);
);
);
};
struct IProcess
{
};
/* End of struct IProcess Declaration */
/* Start of struct IGuestProcess Declaration */
#define IGUESTPROCESS_IID { \
0xdfa39a36, 0x5d43, 0x4840, \
{ 0xa0, 0x25, 0x67, 0xea, 0x95, 0x6b, 0x31, 0x11 } \
}
struct IGuestProcess_vtbl
{
};
struct IGuestProcess
{
};
/* End of struct IGuestProcess Declaration */
/* Start of struct IDirectory Declaration */
#define IDIRECTORY_IID { \
0x1b70dd03, 0x26d7, 0x483a, \
{ 0x88, 0x77, 0x89, 0xbb, 0xb0, 0xf8, 0x7b, 0x70 } \
}
struct IDirectory_vtbl
{
IFsObjInfo * * objInfo
);
};
struct IDirectory
{
};
/* End of struct IDirectory Declaration */
/* Start of struct IGuestDirectory Declaration */
#define IGUESTDIRECTORY_IID { \
0xaf4a8ce0, 0x0725, 0x42b7, \
{ 0x88, 0x26, 0x46, 0xe3, 0xc7, 0xba, 0x73, 0x57 } \
}
struct IGuestDirectory_vtbl
{
};
struct IGuestDirectory
{
};
/* End of struct IGuestDirectory Declaration */
/* Start of struct IFile Declaration */
#define IFILE_IID { \
0xb702a560, 0x6139, 0x4a8e, \
{ 0xa8, 0x92, 0xbb, 0xf1, 0x4b, 0x97, 0xbf, 0x97 } \
}
struct IFile_vtbl
{
IFsObjInfo * * objInfo
);
);
);
);
);
);
);
};
struct IFile
{
};
/* End of struct IFile Declaration */
/* Start of struct IGuestFile Declaration */
#define IGUESTFILE_IID { \
0x60661aec, 0x145f, 0x4d11, \
{ 0xb8, 0x0e, 0x8e, 0xa1, 0x51, 0x59, 0x80, 0x93 } \
}
struct IGuestFile_vtbl
{
};
struct IGuestFile
{
};
/* End of struct IGuestFile Declaration */
/* Start of struct IFsObjInfo Declaration */
#define IFSOBJINFO_IID { \
0x4047ba30, 0x7006, 0x4966, \
{ 0xae, 0x86, 0x94, 0x16, 0x4e, 0x5e, 0x20, 0xeb } \
}
struct IFsObjInfo_vtbl
{
};
struct IFsObjInfo
{
};
/* End of struct IFsObjInfo Declaration */
/* Start of struct IGuestFsObjInfo Declaration */
#define IGUESTFSOBJINFO_IID { \
0xd5cf678e, 0x3484, 0x4e4a, \
{ 0xac, 0x55, 0x32, 0x9e, 0x15, 0x46, 0x2e, 0x18 } \
}
struct IGuestFsObjInfo_vtbl
{
};
struct IGuestFsObjInfo
{
};
/* End of struct IGuestFsObjInfo Declaration */
/* Start of struct IGuest Declaration */
#define IGUEST_IID { \
0x19c32350, 0x0618, 0x4ede, \
{ 0xb0, 0xc3, 0x2b, 0x43, 0x11, 0xbf, 0x0d, 0x9b } \
}
struct IGuest_vtbl
{
nsresult (*GetFacilities)(IGuest *pThis, PRUint32 *facilitiesSize, IAdditionsFacility * **facilities);
);
);
);
);
PRUint32 y,
PRUint32 x,
);
PRUint32 x,
PRUint32 y,
);
);
PRUint32 x,
PRUint32 y,
);
);
);
);
);
);
);
);
};
struct IGuest
{
};
/* End of struct IGuest Declaration */
/* Start of struct IProgress Declaration */
#define IPROGRESS_IID { \
0xc20238e4, 0x3221, 0x4d3f, \
{ 0x88, 0x91, 0x81, 0xce, 0x92, 0xd9, 0xf9, 0x13 } \
}
struct IProgress_vtbl
{
);
);
);
);
);
};
struct IProgress
{
};
/* End of struct IProgress Declaration */
/* Start of struct ISnapshot Declaration */
#define ISNAPSHOT_IID { \
0x0472823b, 0xc6e7, 0x472a, \
{ 0x8e, 0x9f, 0xd7, 0x32, 0xe8, 0x6b, 0x84, 0x63 } \
}
struct ISnapshot_vtbl
{
);
};
struct ISnapshot
{
};
/* End of struct ISnapshot Declaration */
/* Start of struct IMediumAttachment Declaration */
#define IMEDIUMATTACHMENT_IID { \
0x5ee464d6, 0x0613, 0x4331, \
{ 0xb1, 0x54, 0x7c, 0xe1, 0x21, 0x70, 0xef, 0x9f } \
}
struct IMediumAttachment_vtbl
{
};
struct IMediumAttachment
{
};
/* End of struct IMediumAttachment Declaration */
/* Start of struct IMedium Declaration */
#define IMEDIUM_IID { \
0x29989373, 0xb111, 0x4654, \
{ 0x84, 0x93, 0x2e, 0x11, 0x76, 0xcb, 0xa8, 0x90 } \
}
struct IMedium_vtbl
{
);
);
PRUnichar *** snapshotIds
);
);
);
);
);
);
);
PRUnichar *** returnNames,
);
);
);
);
);
);
);
);
);
);
);
};
struct IMedium
{
};
/* End of struct IMedium Declaration */
/* Start of struct IMediumFormat Declaration */
#define IMEDIUMFORMAT_IID { \
0x9bd5b655, 0xea47, 0x4637, \
{ 0x99, 0xf3, 0xaa, 0xd0, 0x94, 0x8b, 0xe3, 0x5b } \
}
struct IMediumFormat_vtbl
{
PRUnichar *** extensions,
);
PRUnichar *** description,
);
};
struct IMediumFormat
{
};
/* End of struct IMediumFormat Declaration */
/* Start of struct IKeyboard Declaration */
#define IKEYBOARD_IID { \
0xf6916ec5, 0xa881, 0x4237, \
{ 0x89, 0x8f, 0x7d, 0xe5, 0x8c, 0xf8, 0x86, 0x72 } \
}
struct IKeyboard_vtbl
{
);
);
};
struct IKeyboard
{
};
/* End of struct IKeyboard Declaration */
/* Start of struct IMouse Declaration */
#define IMOUSE_IID { \
0x05044a52, 0x7811, 0x4f00, \
{ 0xae, 0x3a, 0x0a, 0xb7, 0xff, 0x70, 0x7b, 0x10 } \
}
struct IMouse_vtbl
{
);
PRInt32 x,
PRInt32 y,
);
};
struct IMouse
{
};
/* End of struct IMouse Declaration */
/* Start of struct IFramebuffer Declaration */
#define IFRAMEBUFFER_IID { \
0xb7ed347a, 0x5765, 0x40a0, \
{ 0xae, 0x1c, 0xf5, 0x43, 0xeb, 0x4d, 0xde, 0xaf } \
}
struct IFramebuffer_vtbl
{
PRUint32 x,
PRUint32 y,
);
);
);
);
);
);
};
struct IFramebuffer
{
};
/* End of struct IFramebuffer Declaration */
/* Start of struct IFramebufferOverlay Declaration */
#define IFRAMEBUFFEROVERLAY_IID { \
0x0bcc1c7e, 0xe415, 0x47d2, \
{ 0xbf, 0xdb, 0xe4, 0xc7, 0x05, 0xfb, 0x0f, 0x47 } \
}
struct IFramebufferOverlay_vtbl
{
PRUint32 x,
PRUint32 y
);
};
struct IFramebufferOverlay
{
};
/* End of struct IFramebufferOverlay Declaration */
/* Start of struct IDisplay Declaration */
#define IDISPLAY_IID { \
0xb83ee395, 0x8679, 0x40ca, \
{ 0x8d, 0x60, 0x1a, 0x0c, 0xbe, 0x72, 0x49, 0x30 } \
}
struct IDisplay_vtbl
{
);
);
IFramebuffer * * framebuffer,
);
);
);
);
);
);
PRUint32 x,
PRUint32 y,
);
);
);
PRUint32 x,
PRUint32 y,
);
};
struct IDisplay
{
};
/* End of struct IDisplay Declaration */
/* Start of struct INetworkAdapter Declaration */
#define INETWORKADAPTER_IID { \
0xefa0f965, 0x63c7, 0x4c60, \
{ 0xaf, 0xdf, 0xb1, 0xcc, 0x99, 0x43, 0xb9, 0xc0 } \
}
struct INetworkAdapter_vtbl
{
);
);
PRUnichar *** returnNames,
);
};
struct INetworkAdapter
{
};
/* End of struct INetworkAdapter Declaration */
/* Start of struct ISerialPort Declaration */
#define ISERIALPORT_IID { \
0x937f6970, 0x5103, 0x4745, \
{ 0xb7, 0x8e, 0xd2, 0x8d, 0xcf, 0x14, 0x79, 0xa8 } \
}
struct ISerialPort_vtbl
{
};
struct ISerialPort
{
};
/* End of struct ISerialPort Declaration */
/* Start of struct IParallelPort Declaration */
#define IPARALLELPORT_IID { \
0x0c925f06, 0xdd10, 0x4b77, \
{ 0x8d, 0xe8, 0x29, 0x4d, 0x73, 0x8c, 0x32, 0x14 } \
}
struct IParallelPort_vtbl
{
};
struct IParallelPort
{
};
/* End of struct IParallelPort Declaration */
/* Start of struct IMachineDebugger Declaration */
#define IMACHINEDEBUGGER_IID { \
0xa9abbb7c, 0xd678, 0x43b2, \
{ 0xbe, 0xd2, 0x19, 0xec, 0x0e, 0x32, 0x30, 0x3d } \
}
struct IMachineDebugger_vtbl
{
nsresult (*GetHWVirtExNestedPagingEnabled)(IMachineDebugger *pThis, PRBool *HWVirtExNestedPagingEnabled);
);
);
);
);
);
);
);
);
);
);
);
);
);
);
);
);
);
);
);
};
struct IMachineDebugger
{
};
/* End of struct IMachineDebugger Declaration */
/* Start of struct IUSBController Declaration */
#define IUSBCONTROLLER_IID { \
0x01e6f13a, 0x0580, 0x452f, \
{ 0xa4, 0x0f, 0x74, 0xe3, 0x2a, 0x5e, 0x49, 0x21 } \
}
struct IUSBController_vtbl
{
nsresult (*GetDeviceFilters)(IUSBController *pThis, PRUint32 *deviceFiltersSize, IUSBDeviceFilter * **deviceFilters);
);
);
);
};
struct IUSBController
{
};
/* End of struct IUSBController Declaration */
/* Start of struct IUSBDevice Declaration */
#define IUSBDEVICE_IID { \
0xf8967b0b, 0x4483, 0x400f, \
{ 0x92, 0xb5, 0x8b, 0x67, 0x5d, 0x98, 0xa8, 0x5b } \
}
struct IUSBDevice_vtbl
{
};
struct IUSBDevice
{
};
/* End of struct IUSBDevice Declaration */
/* Start of struct IUSBDeviceFilter Declaration */
#define IUSBDEVICEFILTER_IID { \
0xd6831fb4, 0x1a94, 0x4c2c, \
{ 0x96, 0xef, 0x8d, 0x0d, 0x61, 0x92, 0x06, 0x6d } \
}
struct IUSBDeviceFilter_vtbl
{
};
struct IUSBDeviceFilter
{
};
/* End of struct IUSBDeviceFilter Declaration */
/* Start of struct IHostUSBDevice Declaration */
#define IHOSTUSBDEVICE_IID { \
0x173b4b44, 0xd268, 0x4334, \
{ 0xa0, 0x0d, 0xb6, 0x52, 0x1c, 0x9a, 0x74, 0x0a } \
}
struct IHostUSBDevice_vtbl
{
};
struct IHostUSBDevice
{
};
/* End of struct IHostUSBDevice Declaration */
/* Start of struct IHostUSBDeviceFilter Declaration */
#define IHOSTUSBDEVICEFILTER_IID { \
0x4cc70246, 0xd74a, 0x400f, \
{ 0x82, 0x22, 0x39, 0x00, 0x48, 0x9c, 0x03, 0x74 } \
}
struct IHostUSBDeviceFilter_vtbl
{
};
struct IHostUSBDeviceFilter
{
};
/* End of struct IHostUSBDeviceFilter Declaration */
/* Start of struct IAudioAdapter Declaration */
#define IAUDIOADAPTER_IID { \
0x921873db, 0x5f3f, 0x4b69, \
{ 0x91, 0xf9, 0x7b, 0xe9, 0xe5, 0x35, 0xa2, 0xcb } \
}
struct IAudioAdapter_vtbl
{
};
struct IAudioAdapter
{
};
/* End of struct IAudioAdapter Declaration */
/* Start of struct IVRDEServer Declaration */
#define IVRDESERVER_IID { \
0xd38de40a, 0xc2c1, 0x4e95, \
{ 0xb5, 0xa4, 0x16, 0x7b, 0x05, 0xf5, 0x69, 0x4c } \
}
struct IVRDEServer_vtbl
{
nsresult (*GetVRDEProperties)(IVRDEServer *pThis, PRUint32 *VRDEPropertiesSize, PRUnichar * **VRDEProperties);
);
);
};
struct IVRDEServer
{
};
/* End of struct IVRDEServer Declaration */
/* Start of struct ISharedFolder Declaration */
#define ISHAREDFOLDER_IID { \
0x8388da11, 0xb559, 0x4574, \
{ 0xa5, 0xb7, 0x2b, 0xd7, 0xac, 0xd5, 0xce, 0xf8 } \
}
struct ISharedFolder_vtbl
{
};
struct ISharedFolder
{
};
/* End of struct ISharedFolder Declaration */
/* Start of struct IInternalSessionControl Declaration */
#define IINTERNALSESSIONCONTROL_IID { \
0xcddf451c, 0xa006, 0x4c33, \
{ 0x82, 0x45, 0x63, 0xb3, 0xc9, 0xae, 0x65, 0x86 } \
}
struct IInternalSessionControl_vtbl
{
);
);
);
);
);
);
);
);
);
);
);
);
);
);
);
);
IUSBDevice * device,
);
);
);
);
);
);
);
);
);
);
);
};
struct IInternalSessionControl
{
};
/* End of struct IInternalSessionControl Declaration */
/* Start of struct ISession Declaration */
#define ISESSION_IID { \
0x12F4DCDB, 0x12B2, 0x4EC1, \
{ 0xB7, 0xCD, 0xDD, 0xD9, 0xF6, 0xC5, 0xBF, 0x4D } \
}
struct ISession_vtbl
{
};
struct ISession
{
};
/* End of struct ISession Declaration */
/* Start of struct IStorageController Declaration */
#define ISTORAGECONTROLLER_IID { \
0xa1556333, 0x09b6, 0x46d9, \
{ 0xbf, 0xb7, 0xfc, 0x23, 0x9b, 0x7f, 0xbe, 0x1e } \
}
struct IStorageController_vtbl
{
};
struct IStorageController
{
};
/* End of struct IStorageController Declaration */
/* Start of struct IPerformanceMetric Declaration */
#define IPERFORMANCEMETRIC_IID { \
0x2a1a60ae, 0x9345, 0x4019, \
{ 0xad, 0x53, 0xd3, 0x4b, 0xa4, 0x1c, 0xbf, 0xe9 } \
}
struct IPerformanceMetric_vtbl
{
};
struct IPerformanceMetric
{
};
/* End of struct IPerformanceMetric Declaration */
/* Start of struct IPerformanceCollector Declaration */
#define IPERFORMANCECOLLECTOR_IID { \
0xe22e1acb, 0xac4a, 0x43bb, \
{ 0xa3, 0x1c, 0x17, 0x32, 0x16, 0x59, 0xb0, 0xc6 } \
}
struct IPerformanceCollector_vtbl
{
nsresult (*GetMetricNames)(IPerformanceCollector *pThis, PRUint32 *metricNamesSize, PRUnichar * **metricNames);
PRUnichar ** metricNames,
nsISupports ** objects,
);
PRUnichar ** metricNames,
nsISupports ** objects,
);
PRUnichar ** metricNames,
nsISupports ** objects,
);
PRUnichar ** metricNames,
nsISupports ** objects,
);
PRUnichar ** metricNames,
nsISupports ** objects,
PRUnichar *** returnUnits,
);
};
struct IPerformanceCollector
{
};
/* End of struct IPerformanceCollector Declaration */
/* Start of struct INATEngine Declaration */
#define INATENGINE_IID { \
0x26451b99, 0x3b2d, 0x4dcb, \
{ 0x8e, 0x4b, 0xd6, 0x36, 0x54, 0x21, 0x81, 0x75 } \
}
struct INATEngine_vtbl
{
);
);
);
);
};
struct INATEngine
{
};
/* End of struct INATEngine Declaration */
/* Start of struct IExtPackPlugIn Declaration */
#define IEXTPACKPLUGIN_IID { \
0x58000040, 0xe718, 0x4746, \
{ 0xbb, 0xce, 0x4b, 0x86, 0xd9, 0x6d, 0xa4, 0x61 } \
}
struct IExtPackPlugIn_vtbl
{
};
struct IExtPackPlugIn
{
};
/* End of struct IExtPackPlugIn Declaration */
/* Start of struct IExtPackBase Declaration */
#define IEXTPACKBASE_IID { \
0xf79b75d8, 0x2890, 0x4f34, \
{ 0xff, 0xff, 0xff, 0xff, 0xa1, 0x44, 0xe8, 0x2c } \
}
struct IExtPackBase_vtbl
{
PRUnichar * * licenseText
);
};
struct IExtPackBase
{
};
/* End of struct IExtPackBase Declaration */
/* Start of struct IExtPack Declaration */
#define IEXTPACK_IID { \
0x431685da, 0x3618, 0x4ebc, \
{ 0xb0, 0x38, 0x83, 0x3b, 0xa8, 0x29, 0xb4, 0xb2 } \
}
struct IExtPack_vtbl
{
);
};
struct IExtPack
{
};
/* End of struct IExtPack Declaration */
/* Start of struct IExtPackFile Declaration */
#define IEXTPACKFILE_IID { \
0xb6b49f55, 0xefcc, 0x4f08, \
{ 0xb4, 0x86, 0x56, 0xe8, 0xd8, 0xaf, 0xb1, 0x0b } \
}
struct IExtPackFile_vtbl
{
);
};
struct IExtPackFile
{
};
/* End of struct IExtPackFile Declaration */
/* Start of struct IExtPackManager Declaration */
#define IEXTPACKMANAGER_IID { \
0x3295e6ce, 0xb051, 0x47b2, \
{ 0x95, 0x14, 0x2c, 0x58, 0x8b, 0xfe, 0x75, 0x54 } \
}
struct IExtPackManager_vtbl
{
nsresult (*GetInstalledExtPacks)(IExtPackManager *pThis, PRUint32 *installedExtPacksSize, IExtPack * **installedExtPacks);
IExtPack * * returnData
);
IExtPackFile * * file
);
);
);
);
};
struct IExtPackManager
{
};
/* End of struct IExtPackManager Declaration */
/* Start of struct IBandwidthGroup Declaration */
#define IBANDWIDTHGROUP_IID { \
0xbadea2d7, 0x0261, 0x4146, \
{ 0x89, 0xf0, 0x6a, 0x57, 0xcc, 0x34, 0x83, 0x3d } \
}
struct IBandwidthGroup_vtbl
{
};
struct IBandwidthGroup
{
};
/* End of struct IBandwidthGroup Declaration */
/* Start of struct IBandwidthControl Declaration */
#define IBANDWIDTHCONTROL_IID { \
0xe2eb3930, 0xd2f4, 0x4f87, \
{ 0xbe, 0x17, 0x07, 0x07, 0xe3, 0x0f, 0x01, 0x9f } \
}
struct IBandwidthControl_vtbl
{
);
);
);
);
};
struct IBandwidthControl
{
};
/* End of struct IBandwidthControl Declaration */
/* Start of struct IVirtualBoxClient Declaration */
#define IVIRTUALBOXCLIENT_IID { \
0x5fe0bd48, 0x1181, 0x40d1, \
{ 0x99, 0x1f, 0x3b, 0x02, 0xf2, 0x69, 0xa8, 0x23 } \
}
struct IVirtualBoxClient_vtbl
{
};
struct IVirtualBoxClient
{
};
/* End of struct IVirtualBoxClient Declaration */
/* Start of struct IEventSource Declaration */
#define IEVENTSOURCE_IID { \
0x9b6e1aee, 0x35f3, 0x4f4d, \
{ 0xb5, 0xbb, 0xed, 0x0e, 0xce, 0xfd, 0x85, 0x38 } \
}
struct IEventSource_vtbl
{
);
IEventSource * * result
);
);
);
);
);
);
};
struct IEventSource
{
};
/* End of struct IEventSource Declaration */
/* Start of struct IEventListener Declaration */
#define IEVENTLISTENER_IID { \
0x67099191, 0x32e7, 0x4f6c, \
{ 0x85, 0xee, 0x42, 0x23, 0x04, 0xc7, 0x1b, 0x90 } \
}
struct IEventListener_vtbl
{
);
};
struct IEventListener
{
};
/* End of struct IEventListener Declaration */
/* Start of struct IEvent Declaration */
#define IEVENT_IID { \
0x0ca2adba, 0x8f30, 0x401b, \
{ 0xa8, 0xcd, 0xfe, 0x31, 0xdb, 0xe8, 0x39, 0xc0 } \
}
struct IEvent_vtbl
{
);
};
struct IEvent
{
};
/* End of struct IEvent Declaration */
/* Start of struct IReusableEvent Declaration */
#define IREUSABLEEVENT_IID { \
0x69bfb134, 0x80f6, 0x4266, \
{ 0x8e, 0x20, 0x16, 0x37, 0x1f, 0x68, 0xfa, 0x25 } \
}
struct IReusableEvent_vtbl
{
};
struct IReusableEvent
{
};
/* End of struct IReusableEvent Declaration */
/* Start of struct IMachineEvent Declaration */
#define IMACHINEEVENT_IID { \
0x92ed7b1a, 0x0d96, 0x40ed, \
{ 0xae, 0x46, 0xa5, 0x64, 0xd4, 0x84, 0x32, 0x5e } \
}
struct IMachineEvent_vtbl
{
};
struct IMachineEvent
{
};
/* End of struct IMachineEvent Declaration */
/* Start of struct IMachineStateChangedEvent Declaration */
#define IMACHINESTATECHANGEDEVENT_IID { \
0x5748F794, 0x48DF, 0x438D, \
{ 0x85, 0xEB, 0x98, 0xFF, 0xD7, 0x0D, 0x18, 0xC9 } \
}
{
};
struct IMachineStateChangedEvent
{
};
/* End of struct IMachineStateChangedEvent Declaration */
/* Start of struct IMachineDataChangedEvent Declaration */
#define IMACHINEDATACHANGEDEVENT_IID { \
0xabe94809, 0x2e88, 0x4436, \
{ 0x83, 0xd7, 0x50, 0xf3, 0xe6, 0x4d, 0x05, 0x03 } \
}
{
};
struct IMachineDataChangedEvent
{
};
/* End of struct IMachineDataChangedEvent Declaration */
/* Start of struct IMediumRegisteredEvent Declaration */
#define IMEDIUMREGISTEREDEVENT_IID { \
0x53fac49a, 0xb7f1, 0x4a5a, \
{ 0xa4, 0xef, 0xa1, 0x1d, 0xd9, 0xc2, 0xa4, 0x58 } \
}
struct IMediumRegisteredEvent_vtbl
{
};
struct IMediumRegisteredEvent
{
};
/* End of struct IMediumRegisteredEvent Declaration */
/* Start of struct IMachineRegisteredEvent Declaration */
#define IMACHINEREGISTEREDEVENT_IID { \
0xc354a762, 0x3ff2, 0x4f2e, \
{ 0x8f, 0x09, 0x07, 0x38, 0x2e, 0xe2, 0x50, 0x88 } \
}
struct IMachineRegisteredEvent_vtbl
{
};
struct IMachineRegisteredEvent
{
};
/* End of struct IMachineRegisteredEvent Declaration */
/* Start of struct ISessionStateChangedEvent Declaration */
#define ISESSIONSTATECHANGEDEVENT_IID { \
0x714a3eef, 0x799a, 0x4489, \
{ 0x86, 0xcd, 0xfe, 0x8e, 0x45, 0xb2, 0xff, 0x8e } \
}
{
};
struct ISessionStateChangedEvent
{
};
/* End of struct ISessionStateChangedEvent Declaration */
/* Start of struct IGuestPropertyChangedEvent Declaration */
#define IGUESTPROPERTYCHANGEDEVENT_IID { \
0x3f63597a, 0x26f1, 0x4edb, \
{ 0x8d, 0xd2, 0x6b, 0xdd, 0xd0, 0x91, 0x23, 0x68 } \
}
{
};
struct IGuestPropertyChangedEvent
{
};
/* End of struct IGuestPropertyChangedEvent Declaration */
/* Start of struct ISnapshotEvent Declaration */
#define ISNAPSHOTEVENT_IID { \
0x21637b0e, 0x34b8, 0x42d3, \
{ 0xac, 0xfb, 0x7e, 0x96, 0xda, 0xf7, 0x7c, 0x22 } \
}
struct ISnapshotEvent_vtbl
{
};
struct ISnapshotEvent
{
};
/* End of struct ISnapshotEvent Declaration */
/* Start of struct ISnapshotTakenEvent Declaration */
#define ISNAPSHOTTAKENEVENT_IID { \
0xd27c0b3d, 0x6038, 0x422c, \
{ 0xb4, 0x5e, 0x6d, 0x4a, 0x05, 0x03, 0xd9, 0xf1 } \
}
struct ISnapshotTakenEvent_vtbl
{
};
struct ISnapshotTakenEvent
{
};
/* End of struct ISnapshotTakenEvent Declaration */
/* Start of struct ISnapshotDeletedEvent Declaration */
#define ISNAPSHOTDELETEDEVENT_IID { \
0xc48f3401, 0x4a9e, 0x43f4, \
{ 0xb7, 0xa7, 0x54, 0xbd, 0x28, 0x5e, 0x22, 0xf4 } \
}
struct ISnapshotDeletedEvent_vtbl
{
};
struct ISnapshotDeletedEvent
{
};
/* End of struct ISnapshotDeletedEvent Declaration */
/* Start of struct ISnapshotChangedEvent Declaration */
#define ISNAPSHOTCHANGEDEVENT_IID { \
0x07541941, 0x8079, 0x447a, \
{ 0xa3, 0x3e, 0x47, 0xa6, 0x9c, 0x79, 0x80, 0xdb } \
}
struct ISnapshotChangedEvent_vtbl
{
};
struct ISnapshotChangedEvent
{
};
/* End of struct ISnapshotChangedEvent Declaration */
/* Start of struct IMousePointerShapeChangedEvent Declaration */
#define IMOUSEPOINTERSHAPECHANGEDEVENT_IID { \
0xa6dcf6e8, 0x416b, 0x4181, \
{ 0x8c, 0x4a, 0x45, 0xec, 0x95, 0x17, 0x7a, 0xef } \
}
{
};
{
};
/* End of struct IMousePointerShapeChangedEvent Declaration */
/* Start of struct IMouseCapabilityChangedEvent Declaration */
#define IMOUSECAPABILITYCHANGEDEVENT_IID { \
0xd633ad48, 0x820c, 0x4207, \
{ 0xb4, 0x6c, 0x6b, 0xd3, 0x59, 0x66, 0x40, 0xd5 } \
}
{
};
struct IMouseCapabilityChangedEvent
{
};
/* End of struct IMouseCapabilityChangedEvent Declaration */
/* Start of struct IKeyboardLedsChangedEvent Declaration */
#define IKEYBOARDLEDSCHANGEDEVENT_IID { \
0x6DDEF35E, 0x4737, 0x457B, \
{ 0x99, 0xFC, 0xBC, 0x52, 0xC8, 0x51, 0xA4, 0x4F } \
}
{
};
struct IKeyboardLedsChangedEvent
{
};
/* End of struct IKeyboardLedsChangedEvent Declaration */
/* Start of struct IStateChangedEvent Declaration */
#define ISTATECHANGEDEVENT_IID { \
0x4376693C, 0xCF37, 0x453B, \
{ 0x92, 0x89, 0x3B, 0x0F, 0x52, 0x1C, 0xAF, 0x27 } \
}
struct IStateChangedEvent_vtbl
{
};
struct IStateChangedEvent
{
};
/* End of struct IStateChangedEvent Declaration */
/* Start of struct IAdditionsStateChangedEvent Declaration */
#define IADDITIONSSTATECHANGEDEVENT_IID { \
0xD70F7915, 0xDA7C, 0x44C8, \
{ 0xA7, 0xAC, 0x9F, 0x17, 0x34, 0x90, 0x44, 0x6A } \
}
{
};
struct IAdditionsStateChangedEvent
{
};
/* End of struct IAdditionsStateChangedEvent Declaration */
/* Start of struct INetworkAdapterChangedEvent Declaration */
#define INETWORKADAPTERCHANGEDEVENT_IID { \
0x08889892, 0x1EC6, 0x4883, \
{ 0x80, 0x1D, 0x77, 0xF5, 0x6C, 0xFD, 0x01, 0x03 } \
}
{
nsresult (*GetNetworkAdapter)(INetworkAdapterChangedEvent *pThis, INetworkAdapter * *networkAdapter);
};
struct INetworkAdapterChangedEvent
{
};
/* End of struct INetworkAdapterChangedEvent Declaration */
/* Start of struct ISerialPortChangedEvent Declaration */
#define ISERIALPORTCHANGEDEVENT_IID { \
0x3BA329DC, 0x659C, 0x488B, \
{ 0x83, 0x5C, 0x4E, 0xCA, 0x7A, 0xE7, 0x1C, 0x6C } \
}
struct ISerialPortChangedEvent_vtbl
{
};
struct ISerialPortChangedEvent
{
};
/* End of struct ISerialPortChangedEvent Declaration */
/* Start of struct IParallelPortChangedEvent Declaration */
#define IPARALLELPORTCHANGEDEVENT_IID { \
0x813C99FC, 0x9849, 0x4F47, \
{ 0x81, 0x3E, 0x24, 0xA7, 0x5D, 0xC8, 0x56, 0x15 } \
}
{
};
struct IParallelPortChangedEvent
{
};
/* End of struct IParallelPortChangedEvent Declaration */
/* Start of struct IStorageControllerChangedEvent Declaration */
#define ISTORAGECONTROLLERCHANGEDEVENT_IID { \
0x715212BF, 0xDA59, 0x426E, \
{ 0x82, 0x30, 0x38, 0x31, 0xFA, 0xA5, 0x2C, 0x56 } \
}
{
};
{
};
/* End of struct IStorageControllerChangedEvent Declaration */
/* Start of struct IMediumChangedEvent Declaration */
#define IMEDIUMCHANGEDEVENT_IID { \
0x0FE2DA40, 0x5637, 0x472A, \
{ 0x97, 0x36, 0x72, 0x01, 0x9E, 0xAB, 0xD7, 0xDE } \
}
struct IMediumChangedEvent_vtbl
{
};
struct IMediumChangedEvent
{
};
/* End of struct IMediumChangedEvent Declaration */
/* Start of struct IClipboardModeChangedEvent Declaration */
#define ICLIPBOARDMODECHANGEDEVENT_IID { \
0xcac21692, 0x7997, 0x4595, \
{ 0xa7, 0x31, 0x3a, 0x50, 0x9d, 0xb6, 0x04, 0xe5 } \
}
{
};
struct IClipboardModeChangedEvent
{
};
/* End of struct IClipboardModeChangedEvent Declaration */
/* Start of struct IDragAndDropModeChangedEvent Declaration */
#define IDRAGANDDROPMODECHANGEDEVENT_IID { \
0xe90b8850, 0xac8e, 0x4dff, \
{ 0x80, 0x59, 0x41, 0x00, 0xae, 0x2c, 0x3c, 0x3d } \
}
{
};
struct IDragAndDropModeChangedEvent
{
};
/* End of struct IDragAndDropModeChangedEvent Declaration */
/* Start of struct ICPUChangedEvent Declaration */
#define ICPUCHANGEDEVENT_IID { \
0x4da2dec7, 0x71b2, 0x4817, \
{ 0x9a, 0x64, 0x4e, 0xd1, 0x2c, 0x17, 0x38, 0x8e } \
}
struct ICPUChangedEvent_vtbl
{
};
struct ICPUChangedEvent
{
};
/* End of struct ICPUChangedEvent Declaration */
/* Start of struct ICPUExecutionCapChangedEvent Declaration */
#define ICPUEXECUTIONCAPCHANGEDEVENT_IID { \
0xdfa7e4f5, 0xb4a4, 0x44ce, \
{ 0x85, 0xa8, 0x12, 0x7a, 0xc5, 0xeb, 0x59, 0xdc } \
}
{
};
struct ICPUExecutionCapChangedEvent
{
};
/* End of struct ICPUExecutionCapChangedEvent Declaration */
/* Start of struct IGuestKeyboardEvent Declaration */
#define IGUESTKEYBOARDEVENT_IID { \
0x88394258, 0x7006, 0x40d4, \
{ 0xb3, 0x39, 0x47, 0x2e, 0xe3, 0x80, 0x18, 0x44 } \
}
struct IGuestKeyboardEvent_vtbl
{
};
struct IGuestKeyboardEvent
{
};
/* End of struct IGuestKeyboardEvent Declaration */
/* Start of struct IGuestMouseEvent Declaration */
#define IGUESTMOUSEEVENT_IID { \
0x1f85d35c, 0xc524, 0x40ff, \
{ 0x8e, 0x98, 0x30, 0x70, 0x00, 0xdf, 0x09, 0x92 } \
}
struct IGuestMouseEvent_vtbl
{
};
struct IGuestMouseEvent
{
};
/* End of struct IGuestMouseEvent Declaration */
/* Start of struct IVRDEServerChangedEvent Declaration */
#define IVRDESERVERCHANGEDEVENT_IID { \
0xa06fd66a, 0x3188, 0x4c8c, \
{ 0x87, 0x56, 0x13, 0x95, 0xe8, 0xcb, 0x69, 0x1c } \
}
struct IVRDEServerChangedEvent_vtbl
{
};
struct IVRDEServerChangedEvent
{
};
/* End of struct IVRDEServerChangedEvent Declaration */
/* Start of struct IVRDEServerInfoChangedEvent Declaration */
#define IVRDESERVERINFOCHANGEDEVENT_IID { \
0xdd6a1080, 0xe1b7, 0x4339, \
{ 0xa5, 0x49, 0xf0, 0x87, 0x81, 0x15, 0x59, 0x6e } \
}
{
};
struct IVRDEServerInfoChangedEvent
{
};
/* End of struct IVRDEServerInfoChangedEvent Declaration */
/* Start of struct IUSBControllerChangedEvent Declaration */
#define IUSBCONTROLLERCHANGEDEVENT_IID { \
0x93BADC0C, 0x61D9, 0x4940, \
{ 0xA0, 0x84, 0xE6, 0xBB, 0x29, 0xAF, 0x3D, 0x83 } \
}
{
};
struct IUSBControllerChangedEvent
{
};
/* End of struct IUSBControllerChangedEvent Declaration */
/* Start of struct IUSBDeviceStateChangedEvent Declaration */
#define IUSBDEVICESTATECHANGEDEVENT_IID { \
0x806da61b, 0x6679, 0x422a, \
{ 0xb6, 0x29, 0x51, 0xb0, 0x6b, 0x0c, 0x6d, 0x93 } \
}
{
};
struct IUSBDeviceStateChangedEvent
{
};
/* End of struct IUSBDeviceStateChangedEvent Declaration */
/* Start of struct ISharedFolderChangedEvent Declaration */
#define ISHAREDFOLDERCHANGEDEVENT_IID { \
0xB66349B5, 0x3534, 0x4239, \
{ 0xB2, 0xDE, 0x8E, 0x15, 0x35, 0xD9, 0x4C, 0x0B } \
}
{
};
struct ISharedFolderChangedEvent
{
};
/* End of struct ISharedFolderChangedEvent Declaration */
/* Start of struct IRuntimeErrorEvent Declaration */
#define IRUNTIMEERROREVENT_IID { \
0x883DD18B, 0x0721, 0x4CDE, \
{ 0x86, 0x7C, 0x1A, 0x82, 0xAB, 0xAF, 0x91, 0x4C } \
}
struct IRuntimeErrorEvent_vtbl
{
};
struct IRuntimeErrorEvent
{
};
/* End of struct IRuntimeErrorEvent Declaration */
/* Start of struct IEventSourceChangedEvent Declaration */
#define IEVENTSOURCECHANGEDEVENT_IID { \
0xe7932cb8, 0xf6d4, 0x4ab6, \
{ 0x9c, 0xbf, 0x55, 0x8e, 0xb8, 0x95, 0x9a, 0x6a } \
}
{
};
struct IEventSourceChangedEvent
{
};
/* End of struct IEventSourceChangedEvent Declaration */
/* Start of struct IExtraDataChangedEvent Declaration */
#define IEXTRADATACHANGEDEVENT_IID { \
0x024F00CE, 0x6E0B, 0x492A, \
{ 0xA8, 0xD0, 0x96, 0x84, 0x72, 0xA9, 0x4D, 0xC7 } \
}
struct IExtraDataChangedEvent_vtbl
{
};
struct IExtraDataChangedEvent
{
};
/* End of struct IExtraDataChangedEvent Declaration */
/* Start of struct IVetoEvent Declaration */
#define IVETOEVENT_IID { \
0x9a1a4130, 0x69fe, 0x472f, \
{ 0xac, 0x10, 0xc6, 0xfa, 0x25, 0xd7, 0x50, 0x07 } \
}
struct IVetoEvent_vtbl
{
);
);
);
};
struct IVetoEvent
{
};
/* End of struct IVetoEvent Declaration */
/* Start of struct IExtraDataCanChangeEvent Declaration */
#define IEXTRADATACANCHANGEEVENT_IID { \
0x245d88bd, 0x800a, 0x40f8, \
{ 0x87, 0xa6, 0x17, 0x0d, 0x02, 0x24, 0x9a, 0x55 } \
}
{
};
struct IExtraDataCanChangeEvent
{
};
/* End of struct IExtraDataCanChangeEvent Declaration */
/* Start of struct ICanShowWindowEvent Declaration */
#define ICANSHOWWINDOWEVENT_IID { \
0xadf292b0, 0x92c9, 0x4a77, \
{ 0x9d, 0x35, 0xe0, 0x58, 0xb3, 0x9f, 0xe0, 0xb9 } \
}
struct ICanShowWindowEvent_vtbl
{
};
struct ICanShowWindowEvent
{
};
/* End of struct ICanShowWindowEvent Declaration */
/* Start of struct IShowWindowEvent Declaration */
#define ISHOWWINDOWEVENT_IID { \
0xB0A0904D, 0x2F05, 0x4D28, \
{ 0x85, 0x5F, 0x48, 0x8F, 0x96, 0xBA, 0xD2, 0xB2 } \
}
struct IShowWindowEvent_vtbl
{
};
struct IShowWindowEvent
{
};
/* End of struct IShowWindowEvent Declaration */
/* Start of struct INATRedirectEvent Declaration */
#define INATREDIRECTEVENT_IID { \
0x24eef068, 0xc380, 0x4510, \
{ 0xbc, 0x7c, 0x19, 0x31, 0x4a, 0x73, 0x52, 0xf1 } \
}
struct INATRedirectEvent_vtbl
{
};
struct INATRedirectEvent
{
};
/* End of struct INATRedirectEvent Declaration */
/* Start of struct IHostPCIDevicePlugEvent Declaration */
#define IHOSTPCIDEVICEPLUGEVENT_IID { \
0xa0bad6df, 0xd612, 0x47d3, \
{ 0x89, 0xd4, 0xdb, 0x39, 0x92, 0x53, 0x39, 0x48 } \
}
struct IHostPCIDevicePlugEvent_vtbl
{
};
struct IHostPCIDevicePlugEvent
{
};
/* End of struct IHostPCIDevicePlugEvent Declaration */
/* Start of struct IVBoxSVCAvailabilityChangedEvent Declaration */
#define IVBOXSVCAVAILABILITYCHANGEDEVENT_IID { \
0x97c78fcd, 0xd4fc, 0x485f, \
{ 0x86, 0x13, 0x5a, 0xf8, 0x8b, 0xfc, 0xfc, 0xdc } \
}
{
};
{
};
/* End of struct IVBoxSVCAvailabilityChangedEvent Declaration */
/* Start of struct IBandwidthGroupChangedEvent Declaration */
#define IBANDWIDTHGROUPCHANGEDEVENT_IID { \
0x334df94a, 0x7556, 0x4cbc, \
{ 0x8c, 0x04, 0x04, 0x30, 0x96, 0xb0, 0x2d, 0x82 } \
}
{
nsresult (*GetBandwidthGroup)(IBandwidthGroupChangedEvent *pThis, IBandwidthGroup * *bandwidthGroup);
};
struct IBandwidthGroupChangedEvent
{
};
/* End of struct IBandwidthGroupChangedEvent Declaration */
/* Start of struct IGuestMonitorChangedEvent Declaration */
#define IGUESTMONITORCHANGEDEVENT_IID { \
0x0f7b8a22, 0xc71f, 0x4a36, \
{ 0x8e, 0x5f, 0xa7, 0x7d, 0x01, 0xd7, 0x60, 0x90 } \
}
{
};
struct IGuestMonitorChangedEvent
{
};
/* End of struct IGuestMonitorChangedEvent Declaration */
/* Start of struct IStorageDeviceChangedEvent Declaration */
#define ISTORAGEDEVICECHANGEDEVENT_IID { \
0x8a5c2dce, 0xe341, 0x49d4, \
{ 0xaf, 0xce, 0xc9, 0x59, 0x79, 0xf7, 0xd7, 0x0c } \
}
{
nsresult (*GetStorageDevice)(IStorageDeviceChangedEvent *pThis, IMediumAttachment * *storageDevice);
};
struct IStorageDeviceChangedEvent
{
};
/* End of struct IStorageDeviceChangedEvent Declaration */
#define NS_VIRTUALBOX_CID { \
0xB1A7A4F2, 0x47B9, 0x4A1E, \
{ 0x82, 0xB2, 0x07, 0xCC, 0xD5, 0x32, 0x3C, 0x3F } \
}
/* for compatibility with Win32 */
#define NS_VIRTUALBOXCLIENT_CID { \
0xdd3fc71d, 0x26c0, 0x4fe1, \
{ 0xbf, 0x6f, 0x67, 0xf6, 0x33, 0x26, 0x5b, 0xba } \
}
/* for compatibility with Win32 */
#define NS_SESSION_CID { \
0x3C02F46D, 0xC9D2, 0x4F11, \
{ 0xA3, 0x84, 0x53, 0xF0, 0xCF, 0x91, 0x72, 0x14 } \
}
/* for compatibility with Win32 */
#endif /* !__cplusplus */
#ifdef IN_VBOXXPCOMC
#else
#endif
#ifdef __cplusplus
extern "C" {
#endif
/**
* Function table for dynamic linking.
* Use VBoxGetFunctions() to obtain the pointer to it.
*/
typedef struct VBOXXPCOMC
{
/** The size of the structure. */
unsigned cb;
/** The structure version. */
unsigned uVersion;
unsigned int (*pfnGetVersion)(void);
const char *pszSessionIID,
void (*pfnComUninitialize)(void);
/** Tail version, same as uVersion. */
unsigned uEndVersion;
} VBOXXPCOMC;
/** Pointer to a const VBoxXPCOMC function table. */
/** The current interface version.
* For use with VBoxGetXPCOMCFunctions and to be found in
* VBOXXPCOMC::uVersion. */
/** Typedef for VBoxGetXPCOMCFunctions. */
/** The symbol name of VBoxGetXPCOMCFunctions. */
#if defined(__OS2__)
#else
#endif
#ifdef __cplusplus
}
#endif
#endif /* !___VirtualBox_CXPCOM_h */