cand_tlb.idl

#include "olectl.h"
import "IOMAgent.idl";
import "ComExtension.idl";
import "ReplayAPI.idl";
import "CanoePanel.idl";
import "TrsCtrl1.idl";
import "NMHigh.idl";
import "OsekNM.idl";
 
/* Aktualisieren des helpcontext
 
ComSvr (1-999), CanoePanel (1000-1099), CanEasyExe (1300-1399), OSEK-NM (1400-1499), 
NM-High (1500-1599), Replay (1600-1699), Scheduler (1700-1899), VBAManager (1900-1999), 
UserPanel(2000-2099), Trace(2100-2199), Plot(2200-2299), Signal-Monitor (2300-2399), BSKD(5000-5099),
*/
 
 
[
   uuid(95820E0D-2A7C-40F7-93E4-09714A9F54E0),
   helpfile("ComHelp.chm"),
   version(3.4),
   helpstring("Schleissheimer CanEasy 3.4 Typbibliothek")
]
library CanEasy
{
   importlib("stdole32.tlb");
   importlib("stdole2.tlb");
 
    struct HandleDB
    {
        long lHandle;     
        long lType;       
    };
 
    struct ValueEntry
    {
        long nVal;  
        BSTR sDesc; 
    };
 
    struct ValueRangeEntry
    {
        long nValFrom;  
        long nValTo;    
        BSTR sDesc;     
    };
 // end of Structures_CanEasyCOM
 
    [ v1_enum, helpcontext(1)  ]
    enum BusType
    {
        BUSTYPE_CAN,    
        BUSTYPE_LIN,    
        BUSTYPE_ETH,    
        BUSTYPE_UNKNOWN 
    };  
 
    [ v1_enum, helpcontext(2) ]
    enum CanBusEvent
    {
        CANEVENT_BUSOFF,    
        CANEVENT_PASSIVE,   
        CANEVENT_WARNING,   
        CANEVENT_ACTIVE     
    };
 
    [ v1_enum, helpcontext(3) ]
    enum LinBusEvent
    {
        LINEVENT_NOANSWER,  
        LINEVENT_WAKEUP,    
        LINEVENT_SLEEP,     
        LINEVENT_SYNCERROR, 
        LINEVENT_ERRORMSG,  
        LINEVENT_CRCERROR   
    };
 
    [ v1_enum, helpcontext(4) ]
    enum LinBusState
    {
        LINSTATE_WAKEUP,    
        LINSTATE_SLEEP,     
    };
 
    [ v1_enum, helpcontext(5) ]
    enum LinBusError
    {
        LINERROR_NOANSWER,  
        LINERROR_SYNCERROR, 
        LINERROR_ERRORMSG,  
        LINERROR_CRCERROR   
    };
 
    [ v1_enum, helpcontext(6) ]
    enum AttrType
    {
        // Die zugewiesenen Werte dienen dazu, dass dieses Enum direkt in
        // AttributeTypes in Attributes.h konvertiert werden kann!
        ATTRTYPE_STRING = 0,    
        ATTRTYPE_INT = 1,       
        ATTRTYPE_FLOAT = 2,     
        ATTRTYPE_HEX = 4,       
        ATTRTYPE_QWORD = 5,     
        ATTRTYPE_BOOL = 6,      
        ATTRTYPE_ENUM = 7,      
    };
 
    [ v1_enum, helpcontext(7) ]
    enum ValueType
    {
        VALUETYPE_EMPTY = 0,                            
        VALUETYPE_CHAR, VALUETYPE_CHAR_VECTOR,          
        VALUETYPE_UCHAR, VALUETYPE_UCHAR_VECTOR,        
        VALUETYPE_INT, VALUETYPE_INT_VECTOR,            
        VALUETYPE_UINT, VALUETYPE_UINT_VECTOR,          
        VALUETYPE_INT64, VALUETYPE_INT64_VECTOR,        
        VALUETYPE_UINT64, VALUETYPE_UINT64_VECTOR,      
        VALUETYPE_DOUBLE, VALUETYPE_DOUBLE_VECTOR,      
        VALUETYPE_STRING, VALUETYPE_STRING_VECTOR,      
        VALUETYPE_POINTER, VALUETYPE_POINTER_VECTOR,    
        VALUETYPE_SHORT, VALUETYPE_SHORT_VECTOR,        
        VALUETYPE_USHORT, VALUETYPE_USHORT_VECTOR,      
        VALUETYPE_FLOAT, VALUETYPE_FLOAT_VECTOR         
    };
 
    [ v1_enum, helpcontext(8) ]
    enum EnvVarType
    {
        ENVVAR_BYTE = 0,    
        ENVVAR_WORD,        
        ENVVAR_DWORD,       
        ENVVAR_QWORD,       
        ENVVAR_BOOL,        
        ENVVAR_INTEGER,     
        ENVVAR_DOUBLE,      
        ENVVAR_STRING,      
        ENVVAR_INVALID      
    };
 
    [ v1_enum, helpcontext(9) ]
    enum GenMsgMode
    {
        MSGMODE_OFF,    
        MSGMODE_ADAPT,  
        MSGMODE_FULL    
    };
 
    [ v1_enum, helpcontext(10) ]
    enum SigType
    {         
        SigTypeBool,            
        SigTypeEdit1,           
        SigTypeEdit2,           
        SigTypeCombo,           
        SigTypeInvalid = 0xFF   
    };
 
    [ v1_enum, helpcontext(11) ]
    enum ValueDisplayType
    {         
        DisplayType_Check,           
        DisplayType_Slider,          
        DisplayType_Edit,            
        DisplayType_Combo            
    };
 
    [ v1_enum, helpcontext(12) ]
    enum ByteOrder
    {
        BYTEORDER_INTEL,    
        BYTEORDER_MOTOROLA  
    };
 
    [ v1_enum, helpcontext(13) ]
    enum SigValType
    {
        SigValTypeSigned,   
        SigValTypeUnsigned, 
        SigValTypeFloat,    
        SigValTypeDouble    
    };
 
    [ v1_enum, helpcontext(14) ]
    enum DisplayValueType
    {
        DisplayValueType_Decimal,   
        DisplayValueType_Hex        
    };
 
    [ v1_enum, helpcontext(15) ]
    enum ValueConversionType
    {
        ValueType_NoMath,       
        ValueType_Signed,       
        ValueType_Unsigned      
    };  
 
    [ v1_enum, helpcontext(16) ]
    enum CallbackPosition
    {
        PositionFirst,      
        PositionNeutral,    
        PositionLast        
    };   
 
    [ v1_enum, helpcontext(17) ]
    enum ReportType
    {
        ReportTypeInformation,  
        ReportTypeWarning,      
        ReportTypeError         
    };
  
    [ v1_enum ]
    enum ReportTypeFilter
    {
        ReportTypeFilterNone,                   
        ReportTypeFilterInformation,            
        ReportTypeFilterWarning,                
        ReportTypeFilterInformationAndWarning,  
        ReportTypeFilterError,                  
        ReportTypeFilterInformationAndError,    
        ReportTypeFilterWarningAndError,        
        ReportTypeFilterAll                     
    };
 
    [ v1_enum ]
    enum RecordEntryType
    {
        MsgRecordEntry,         
        CanBusErrorRecordEntry, 
        CanBusStateRecordEntry, 
        LinBusStateRecordEntry, 
        MarkerRecordEntry,      
        EnvVarRecordEntry,      
        XcpRecordEntry,         
        DiagServiceRecordEntry  
    };
 
    [ v1_enum, helpcontext(19) ]
    enum RecordChangedEvent
    {
        RecordUnload,   
        RecordLoad      
    };
 
    [ v1_enum, helpcontext(20) ]
    enum MsgRecordEntryType
    {
        CanMsgRecordEntry,      
        LinMsgRecordEntry,      
        FlexrayMsgRecordEntry   
    };
 
    [ v1_enum, helpcontext(21) ]
    enum LinChecksumVersion
    {
        LinChecksumVersion1,    
        LinChecksumVersion2     
    };
 
    [ v1_enum, helpcontext(22) ]
    enum DatabaseType
    {
        NoneDatabaseType,           
        BusDatabaseType,            
        ControlUnitDatabaseType,    
        MessageDatabaseType,        
        SignalDatabaseType          
    };
 
    [ v1_enum/*, helpcontext(23)*/]
    enum CanEasyMenuControlType
    {
        ControlTypeText,            
        ControlTypeSeparator,       
        ControlTypePopup            
    };
 
    [ v1_enum ]
    enum DatabaseBrowse_Show
    {
        ShowAll,                   
        ShowBus,                   
        ShowEcu,                   
        ShowMessage,               
        ShowSignal                 
    };
 
    [ v1_enum]
    enum DatabaseBrowse_Select
    {
        SelectBus,                 
        SelectBusEcu,              
        SelectBusEcuMessage,       
        SelectBusEcuMessageSignal, 
        SelectBusEcuSignal,        
        SelectBusMessage,          
        SelectBusMessageSignal,    
        SelectBusSignal,           
        SelectEcu,                 
        SelectEcuMessage,          
        SelectEcuMessageSignal,    
        SelectEcuSignal,           
        SelectMessage,             
        SelectMessageSignal,       
        SelectSignal,              
        SelectAny                  
    };
 
    [v1_enum]
    enum StartMode
    {
        StartWithSimulation,    
        StartManuel             
    };
 
    [v1_enum]
    enum TimeMode
    {
        TimeModeRelative,   
        TimeModeAbsolute    
    };
 
    [v1_enum]
    enum TimerMode
    {
        TimerModeInterval,  
        TimerModeOneShot    
    };
 
    [v1_enum]
    enum TimerStatus
    {
        TimerStatusActive,      
        TimerStatusSuspended,   
        TimerStatusStopped      
    };
 
    [v1_enum]
    enum DirectionFilter
    {
        FilterRx,   
        FilterTx,   
        FilterRxTx  
    };
 
    [v1_enum]
    enum TransmissionState
    {
        Undefined,   
        Pending,     
        Ok,          
        Error,       
        Timeout      
    };
 
    [v1_enum]
    enum DataEntryType
    {
        Static,     
        Dynamic,    
        Array       
    };
 
    [v1_enum, helpcontext(0)]
    enum TransmissionFlags
    {        
        TransmissionFlags_None = 0,                         
        TransmissionFlags_CAN_BaudrateSwitch = 1,           
        TransmissionFlags_CAN_Highvoltage = 2,              
        TransmissionFlags_CAN_Remoteframe = 4,              
        TransmissionFlags_LIN_LinChecksumVersion1 = 100,    
        TransmissionFlags_LIN_LinChecksumVersion2 = 300,    
        TransmissionFlags_ForceMaxSize = 0x7fffffff,
    };
 
    [v1_enum]
    enum ChangeContext
    {
        ChangeContext_Auto, 
        ChangeContext_User  
    };
 
    //IVstaIntegration interface used to load add-ins
    [v1_enum, helpcontext(892)]
    enum AddInStatus
    {
        ADDINSTATUS_UNKNOWN,            
        ADDINSTATUS_STOPPED,            
        ADDINSTATUS_RUNNING_RELEASE,    
        ADDINSTATUS_RUNNING_DEBUG,      
    };
    //IVstaIntegration interface used to load add-ins
    [v1_enum, helpcontext(893)]
    enum AddInLanguage
    {
        VB,     
        CSHARP, 
    };
 
    [v1_enum, helpcontext(918)]
    enum KeyModifier
    {
        /* These are bitmasks! */
        NoKeyModifier = 0x00,       
        AltKeyModifier = 0x01,      
        CtrlKeyModifier = 0x02,     
        ShiftKeyModifier = 0x04,    
        WinKeyModifier = 0x08       
    };
 // end of Enumerations_CanEasyCOM
 
    [
        object,
        uuid(D6A60B79-0274-4513-BE0B-B21C26DB7728),
        dual,
        helpstring("IArgs-Schnittstelle"),
        pointer_default(unique),
    ]
    interface IEventArgs : IDispatch
    {
        [propget, id(1), helpstring("Property Empty")] 
        HRESULT Empty([out, retval] VARIANT_BOOL*);
    };
 
    
 
   [
      uuid(B2FE5DE7-23CB-493F-9430-2BA0405860AA),
      helpstring("EventArgs Class"),
   ]
   coclass EventArgs
   {
      [default] interface IEventArgs;
   };
 
    [
        object,
        uuid(7B1211D8-FD7E-4EC9-87FF-ABF8E7F272D3),
        dual,
        nonextensible,
        pointer_default(unique),
        helpstring("IAppWindow-Schnittstelle"),
        helpcontext(24)
    ]
    interface IAppWindow : IDispatch
    {
        [id(1), helpstring("Methode Open"), helpcontext(25)] 
        HRESULT Open(void);
        [id(2), helpstring("Methode Close"), helpcontext(26)] 
        HRESULT Close(void);
        [id(3), helpstring("Methode ChangePosition"), helpcontext(27)]
        HRESULT ChangePosition([in] long lX, [in] long lY);
        [propget, id(4), helpstring("Eigenschaft x"), helpcontext(28)]
        HRESULT x([out, retval] LONG*);
        [propget, id(5), helpstring("Eigenschaft y"), helpcontext(29)] 
        HRESULT y([out, retval] LONG*);
        [id(6), helpstring("Methode MinimizeToTray"), helpcontext(30)] 
        HRESULT MinimizeToTray(void);
        [id(7), helpstring("Methode MaximizeFromTray"), helpcontext(31)]
        HRESULT MaximizeFromTray(void);
    };
 
    [
        uuid(1948386A-E11F-4A49-8103-F30F093E64C4),
        helpstring("AppWindow Class"),
        helpcontext(946)
    ]
    coclass AppWindow
    {
        [default] interface IAppWindow;
        interface ISupportErrorInfo;
    };
 
    [
        object,
        uuid(5EC3427B-FFA3-43b4-9034-BF42AA8D8AAB),
        dual,
        nonextensible,
        helpstring("IBoolValue-Schnittstelle"),
        pointer_default(unique),
        helpcontext(32)
    ]
    interface IBoolValue : IDispatch
    {
        [propget, id(DISPID_VALUE), helpstring("Eigenschaft Value"), helpcontext(33)]
        HRESULT Value([out, retval] VARIANT_BOOL*);
        [propput, id(DISPID_VALUE), helpstring("Eigenschaft Value"), helpcontext(34)]
        HRESULT Value([in] VARIANT_BOOL boVal);
    };
 
    [
        uuid(1D7B3F8E-CCF3-4f49-99F2-7A6EFED2B475),
        helpstring("BoolValue Class")
    ]
    coclass BoolValue
    {
        [default] interface IBoolValue;      
    };
 
    [
        object,
        uuid(09324022-4362-4614-B10B-969D6C5A09B6),
        dual,
        helpstring("IMessageId-Schnittstelle"),
        pointer_default(unique),
        helpcontext(35)
    ]
    interface IMessageId : IDispatch
    {
        [propget, id(1), helpstring("Eigenschaft Plain"), helpcontext(36)]
        HRESULT Plain([out, retval] long*);
        [propget, id(DISPID_VALUE), helpstring("Eigenschaft Raw"), helpcontext(37)]
        HRESULT Raw([out, retval] long*);
        [propput, id(DISPID_VALUE), helpstring("Eigenschaft Raw"), helpcontext(38)]
        HRESULT Raw([in] long lRawId);
    };
   
    [
        object,
        uuid(04F4AE40-C517-493F-B05F-04A77086A794),
        dual,
        helpstring("ILinMessageId-Schnittstelle"),
        pointer_default(unique),
        hidden,
        helpcontext(39)
    ]
    interface ILinMessageId : IMessageId
    {
    };
 
    [
        uuid(A449DE15-E9D1-4E50-9055-76D31C9536A3),
            helpstring("LinMessageId Class"),
            helpcontext(948)
    ]
    coclass LinMessageId
    {
        [default] interface ILinMessageId;
    };
 
    [
        object,
        uuid(330216EE-CC96-47B7-A6BB-25AD3856A87C),
        dual,
        helpstring("ICanMessageId-Schnittstelle"),
        pointer_default(unique),
        hidden,
        helpcontext(40)
    ]
    interface ICanMessageId : IMessageId
    {
        [propput, id(2), helpstring("Eigenschaft IsExtended"), helpcontext(41)]
        HRESULT IsExtended([in] VARIANT_BOOL boIsExtended);
        [propget, id(2), helpstring("Eigenschaft IsExtended"), helpcontext(42)]
        HRESULT IsExtended([out, retval] VARIANT_BOOL*);
    };
 
    [
        uuid(9C2CCF8B-0C7A-4277-92E5-E916C17326D3),
            helpstring("CanMessageId Class"),
            helpcontext(947)
    ]
    coclass CanMessageId
    {
        [default] interface ICanMessageId;
    };
 
    [
        object,
        uuid(3C035F7D-C643-4DCA-B506-9542B9841569),
        dual,
        helpstring("IJ1939MessageId-Schnittstelle"),
        pointer_default(unique),
        hidden,
        helpcontext(43)
    ]
    interface IJ1939MessageId : IMessageId
    {
        [propput, id(2), helpstring("Eigenschaft Priority"), helpcontext(44)]
        HRESULT Priority([in] long lPriority);
        [propget, id(2), helpstring("Eigenschaft Priority"), helpcontext(45)]
        HRESULT Priority([out, retval] long*);
        [propput, id(3), helpstring("Eigenschaft Pgn"), helpcontext(46)]
        HRESULT Pgn([in] long lPgn);
        [propget, id(3), helpstring("Eigenschaft Pgn"), helpcontext(47)]
        HRESULT Pgn([out, retval] long*);
        [propput, id(4), helpstring("Eigenschaft SrcAddr"), helpcontext(48)]
        HRESULT SrcAddr([in] long lScrAddr);
        [propget, id(4), helpstring("Eigenschaft SrcAddr"), helpcontext(49)]
        HRESULT SrcAddr([out, retval] long*);
        [propput, id(5), helpstring("Eigenschaft DstAddr"), helpcontext(50)]
        HRESULT DstAddr([in] long lDstAddr);
        [propget, id(5), helpstring("Eigenschaft DstAddr"), helpcontext(51)]
        HRESULT DstAddr([out, retval] long*);
    };
 
    [
        uuid(E8753B79-C4E1-46F7-8D6E-C2C7C0C34B3A),
        helpstring("J1939MessageId Class"),
        helpcontext(949)
    ]
    coclass J1939MessageId
    {
        [default] interface IJ1939MessageId;
    };
 
    [
        object,
        uuid(FE26D10A-57C6-4BCA-BB24-015722BA760F),
        dual,
        nonextensible,
        helpstring("IReport-Schnittstelle"),
        pointer_default(unique),
        helpcontext(0)
    ]
    interface IReportEntry : IDispatch
    {
        [propget, id(1), helpstring("Eigenschaft Type"), helpcontext(0)]
        HRESULT Type([out, retval] enum ReportType*);
        [propget, id(2), helpstring("Eigenschaft Timestamp"), helpcontext(0)]
        HRESULT Timestamp([out, retval] VARIANT*);
        [propget, id(3), helpstring("Eigenschaft Text"), helpcontext(0)]
        HRESULT Text([out, retval] BSTR*);
        [propget, id(4), helpstring("Eigenschaft Window"), helpcontext(0)]
        HRESULT Window([out, retval] BSTR*);
    };
 
    [
        uuid(799D7E4E-C336-453D-8098-934221D8DC97),
        helpstring("Report Class"),
        helpcontext(0)
    ]
    coclass ReportEntry
    {
        [default] interface IReportEntry;
    };
 
    [
        object,
        uuid(FF90D87A-09A5-4C69-97B1-B5B3DCCC20F6),
        dual,
        nonextensible,
        helpstring("IReportCol-Schnittstelle"),
        pointer_default(unique),
        helpcontext(0)
    ]
    interface IReportEntryCol : IDispatch
    {
        [propget, id(DISPID_NEWENUM), helpstring("Eigenschaft _NewEnum"), restricted, hidden, helpcontext(0)] //VSTAHidden
        HRESULT _NewEnum([out, retval] IUnknown**);
        [propget, id(DISPID_VALUE), helpstring("Eigenschaft Item"), helpcontext(0)]
        HRESULT Item([in] VARIANT vIndex, [out, retval] IReportEntry**);
    };
 
    [
        uuid(05C4FA87-F01C-4046-A6D8-4CF7397549EC),
        helpstring("Report Class"),
        helpcontext(0)
    ]
    coclass ReportEntryCol
    {
        [default] interface IReportEntryCol;
    };
 
    [
        object,
        uuid(5E1C76FE-5735-42e8-B530-AD941D8D9423),
        dual,
        nonextensible,
        helpstring("IReportWnd-Schnittstelle"),
        pointer_default(unique),
        helpcontext(52)
    ]
    interface IReportWnd : IDispatch
    {
        [id(1), helpstring("Methode Write"), helpcontext(53)]
        HRESULT Write([in] BSTR sText, [in] enum ReportType enType);
        [id(2), helpstring("Methode Clear"), helpcontext(54)]
        HRESULT Clear();
        [id(3), helpstring("Methode Delete"), helpcontext(55)]
        HRESULT Delete();
        [id(4), helpstring("Methode GetReports"), helpcontext(60)]
        HRESULT GetReports([in] long entries, [in] enum ReportTypeFilter enfilter, [out, retval] IReportEntryCol**);
    };
 
    [
        uuid(61881851-E587-463b-965A-9141D7ED5C77),
        helpstring("ReportWnd Class"),
        helpcontext(56)
    ]
    coclass ReportWnd
    {
        [default] interface IReportWnd;      
    };
 
    [
        object,
        uuid(E9F8B555-8D7E-417e-92CD-407B4A395724),
        dual,
        nonextensible,
        helpstring("IReportWndCol-Schnittstelle"),
        pointer_default(unique),
        helpcontext(57)
    ]
    interface IReportWndCol : IDispatch
    {
        [propget, id(DISPID_NEWENUM), helpstring("Eigenschaft _NewEnum"), restricted, hidden, helpcontext(58)] //VSTAHidden
        HRESULT _NewEnum([out, retval] IUnknown**); 
        [propget, id(DISPID_VALUE), helpstring("Eigenschaft Item"), helpcontext(59)]
        HRESULT Item([in] VARIANT vIndex, [out, retval] IReportWnd**);
        [id(1), helpstring("Methode Add"), helpcontext(60)]
        HRESULT Add([in] BSTR sName, [out, retval] IReportWnd**);
    };
 
    [
        uuid(102A265E-0DD1-4d05-B76F-14AEAC5397B9),
        helpstring("ReportWndCol Class"),
        helpcontext(61)
    ]
    coclass ReportWndCol
    {
        [default] interface IReportWndCol;      
    };
 
    [
        object,
        uuid(75F1329D-F283-4D01-AE74-BEFFC2598AC7),
        dual,
        nonextensible,
        helpstring("ISimulation-Schnittstelle"),
        pointer_default(unique),
        helpcontext(62)
    ]
    interface ISimulation : IDispatch
    {
        [id(1), helpstring("Methode Start"), helpcontext(63)]
        HRESULT Start();
        [id(2), helpstring("Methode Stop"), helpcontext(64)]
        HRESULT Stop();
        [propget, id(3), helpstring("Eigenschaft SimulationIsRunning"), helpcontext(65)]
        HRESULT SimulationIsRunning([out, retval] VARIANT_BOOL*);
        [propget, id(4), helpstring("Eigenschaft TimestampAsDouble"), helpcontext(66)]
        HRESULT TimestampAsDouble([out, retval] double*);
        [propget, id(5), helpstring("Eigenschaft TimestampAsUint64"), helpcontext(67)]
        HRESULT TimestampAsUint64([out, retval] VARIANT*);
    };       
 
    [
        uuid(07E64A87-C70C-4370-B59C-48F1802173B0),
        helpstring("_ISimulationEvents-Schnittstelle"),
        helpcontext(833)
    ]
    dispinterface _ISimulationEvents
    {
    properties:
    methods:
        [id(1), helpcontext(834)]
        HRESULT OnSimulationStarted(void);
        [id(2), helpstring("Methode OnSimulationStopped - Wird vom COM-Thread aufgerufen.d"), helpcontext(835)]
        HRESULT OnSimulationStopped(void);             
        [id(3), helpstring("Methode OnSimulationStart - Wird vom COM-Thread aufgerufen."), helpcontext(836)]
        HRESULT OnSimulationStart(void);
        [id(4), helpstring("Methode OnIdle - Wird vom COM-Thread aufgerufen."), helpcontext(837)]
        HRESULT OnIdle(void);
        [id(5), helpstring("Methode OnWorkspaceLoaded - Wird vom COM-Thread aufgerufen."), helpcontext(838)]
        HRESULT OnWorkspaceLoaded(void);
        [id(6), helpstring("Methode OnWorkspaceUnload - Wird vom COM-Thread aufgerufen."), helpcontext(839)]
        HRESULT OnWorkspaceUnload(void);
        [id(30), helpstring("Methode OnSimulationStartedSync - Wird vom Auslöser-Thread aufgerufen."), restricted, hidden, helpcontext(840)]
        HRESULT OnSimulationStartedSync(void);
        [id(31), helpstring("Methode OnSimulationStoppedSync - Wird vom Auslöser-Thread aufgerufen."), restricted, hidden, helpcontext(841)]
        HRESULT OnSimulationStoppedSync(void);
        [id(32), helpstring("Methode OnSimulationStartSync - Wird vom Auslöser-Thread aufgerufen."), restricted, hidden, helpcontext(842)]
        HRESULT OnSimulationStartSync(void);
        [id(34), helpstring("Methode OnWorkspaceLoadedSync - Wird vom Auslöser-Thread aufgerufen."), restricted, hidden, helpcontext(843)]
        HRESULT OnWorkspaceLoadedSync(void);
        [id(35), helpstring("Methode OnWorkspaceUnloadSync - Wird vom Auslöser-Thread aufgerufen."), restricted, hidden, helpcontext(844)]
        HRESULT OnWorkspaceUnloadSync(void);
    };
 
    [
        uuid(90950AE4-FEDB-449E-B38A-D9D3EB78F497),
        helpstring("Simulation Class"),
        helpcontext(845)
    ]
    coclass Simulation
    {
        [default] interface ISimulation;
        [default, source] dispinterface _ISimulationEvents;
    };
 
    [
        object,
        uuid(DED7227E-C38C-43D2-9EB0-FB6F16B89F3D),
        dual,
        nonextensible,
        helpstring("IObjectFilter-Schnittstelle"),
        pointer_default(unique),
        helpcontext(68)
    ]
    interface IObjectFilter : IDispatch
    {
        [propget, id(1), helpstring("Eigenschaft BusName"), helpcontext(69)] 
        HRESULT BusName([out, retval] BSTR*);
        [propput, id(1), helpstring("Eigenschaft BusName"), helpcontext(70)] 
        HRESULT BusName([in] BSTR sNewVal);
        [propget, id(2), helpstring("Eigenschaft EcuName"), helpcontext(71)]
        HRESULT EcuName([out, retval] BSTR*);
        [propput, id(2), helpstring("Eigenschaft EcuName"), helpcontext(72)] 
        HRESULT EcuName([in] BSTR sNewVal);
        [propget, id(3), helpstring("Eigenschaft MsgID"), helpcontext(73)]
        HRESULT MsgID([out, retval] IMessageId**);
        [propget, id(4), helpstring("Eigenschaft MsgName"), helpcontext(74)]
        HRESULT MsgName([out, retval] BSTR*);
        [propput, id(4), helpstring("Eigenschaft MsgName"), helpcontext(75)] 
        HRESULT MsgName([in] BSTR sNewVal);
        [propget, id(5), helpstring("Eigenschaft SigName"), helpcontext(76)]
        HRESULT SigName([out, retval] BSTR*);
        [propput, id(5), helpstring("Eigenschaft SigName"), helpcontext(77)] 
        HRESULT SigName([in] BSTR sNewVal);
        [propget, id(6), helpstring("Eigenschaft AttrName"), helpcontext(78)]
        HRESULT AttrName([out, retval] BSTR*);
        [propput, id(6), helpstring("Eigenschaft AttrName"), helpcontext(79)] 
        HRESULT AttrName([in] BSTR sNewVal);
        [propget, id(7), helpstring("Eigenschaft AttrValue"), helpcontext(80)] 
        HRESULT AttrValue([out, retval] BSTR*);
        [propput, id(7), helpstring("Eigenschaft AttrValue"), helpcontext(81)] 
        HRESULT AttrValue([in] BSTR sNewVal);
    };
 
    [
        uuid(82221FF0-001D-4498-A834-14155EC5C005),
        helpstring("ObjectFilter Class"),
        helpcontext(830)
    ]
    coclass ObjectFilter
    {
        [default] interface IObjectFilter;
    };
 
    [
        object,
        uuid(8A2BB991-7931-41C0-AAC0-A8003B1B36F0),
        dual,
        helpstring("ICol-Schnittstelle"),
        pointer_default(unique),
        helpcontext(82),
        hidden
    ]
    interface ICol : IDispatch
    {      
        [propget, id(DISPID_NEWENUM), helpstring("Eigenschaft _NewEnum"), restricted, hidden, helpcontext(83)] //VSTAHidden 
        HRESULT _NewEnum([out, retval] IUnknown**);
        [propget, id(3), helpcontext(84)] 
        HRESULT Count([out,retval] long*);
    };
 
   interface IDatabaseItem;
   interface IBus;
   interface IValue;
   interface IDatabaseItemCol;
   interface IAttribute;
   interface IAttrCol;   
   interface IConversion;
   interface IValueTable;
   interface INamespaceCol;
 
    [
        object,
        uuid(5D1AF933-B19A-49D5-925E-8429EC992BFE),
        dual,
        helpstring("IDatabaseItem-Schnittstelle"),
        pointer_default(unique),
        helpcontext(85)
    ]
    interface IDatabaseItem : IDispatch
    {    
        [propget, id(899), helpcontext(86)] HRESULT Name([out, retval] BSTR*);
        [propput, id(899), helpcontext(87)] HRESULT Name([in] BSTR sNewVal);
 
        [id(900), helpcontext(88)] HRESULT Init();
        [id(901), helpcontext(89)] HRESULT Delete();
        [id(902), helpcontext(90)] HRESULT DeleteChildren();
        [id(903), helpcontext(91)] HRESULT DeleteProperties();
        [id(904), helpcontext(92)] HRESULT IsParent([in]IDatabaseItem* pItem, [out, retval] VARIANT_BOOL*);
 
        [propget, id(905), helpcontext(93)] HRESULT Parent([out, retval] IDatabaseItem**);
        [propput, id(905), helpcontext(94)] HRESULT Parent([in] IDatabaseItem* pItem);
 
        [propget, id(906), helpcontext(95)] HRESULT Children([out, retval] IDatabaseItemCol**);
        [propget, id(907), helpcontext(96)] HRESULT Attributes([out, retval] IAttrCol**);
        [propget, id(908), helpcontext(97)] HRESULT Attribute([in] BSTR sName, [out, retval] IAttribute**);
        [propget, id(909), helpcontext(98)] HRESULT Description([out, retval] IAttribute**);
        [propget, id(910), helpcontext(99)] HRESULT Deleted([out, retval] VARIANT_BOOL*);
        [propget, id(911), helpcontext(100)] HRESULT Visible([out, retval] VARIANT_BOOL*);
        [propput, id(911), helpcontext(101)] HRESULT Visible([in] VARIANT_BOOL boVal);
        [propget, id(912), helpcontext(102)] HRESULT StringRef([out, retval] BSTR*);
        [propput, id(912), helpcontext(0)]  HRESULT StringRef([in] BSTR val);
        [propget, id(913), helpcontext(103)] HRESULT TypeString([out, retval] BSTR*);
        [propget, id(914), restricted, hidden, helpcontext(104)] HRESULT Handle([out, retval] struct HandleDB*); //VSTAHidden
#ifdef _WIN64
 
        [propget, id(915), restricted, hidden, helpcontext(105)] HRESULT Pointer([out, retval] LONG_PTR*); //VSTAHidden     /* FIXME_64Bit */
#else
 
        [propget, id(915), restricted, hidden, helpcontext(105)] HRESULT Pointer([out, retval] long*); //VSTAHidden
#endif
 
        [id(916), helpcontext(106)] HRESULT UpdateReference([out, retval] VARIANT_BOOL*);
        [id(917), helpcontext(107)] HRESULT GetObjectByStringRef([in] BSTR sText, [out, retval] IDatabaseItem**);
        [propget, id(918), helpcontext(108)] HRESULT Namespaces([out, retval] INamespaceCol**);
        [propget, id(919), helpcontext(109)] HRESULT Color([out, retval] long*);
        [propput, id(919), helpcontext(110)] HRESULT Color([in] long lColor);
        [id(920), helpcontext(0)] HRESULT Transmit([out, retval] VARIANT_BOOL* pResult);
        [id(921), helpcontext(0)] HRESULT Copy([out, retval] IDatabaseItem**);
        [id(922), helpcontext(0)] HRESULT TransmitOn([in] IBus* pBus, [out, retval] VARIANT_BOOL*);
        [id(923), helpcontext(0)] HRESULT WaitForTransmit([in] long timeout);
        [propget, id(924), helpcontext(0)] HRESULT TransmissionState([out, retval] enum TransmissionState*);
        [id(925), helpcontext(0)] HRESULT TransmitAndWait([out, retval] VARIANT_BOOL*);
    };  
 
 
 
   interface ITransmissionEvent;
   interface ITransmissionData;
 
    [
        object,
        uuid(0DB06124-C89E-40EC-9ECE-422B3AE45110),
        dual,
        pointer_default(unique),
        helpcontext(111)
    ]
    interface IDatabaseItemBase : IDatabaseItem
    {
        [id(1), helpcontext(0)] HRESULT ActivateChangeEvents([in] VARIANT_BOOL recursive, [in] VARIANT_BOOL multithread);
        [id(2), helpcontext(0)] HRESULT DeactivateChangeEvents();
        [propget, id(3), helpcontext(0)] HRESULT DBItem([out, retval] IDatabaseItem**);
        [propput, id(3), helpcontext(0)] HRESULT DBItem([in] IDatabaseItem* pItem);
        [propget, id(4), helpcontext(0)]  HRESULT TransmissionEvent([out, retval] ITransmissionEvent**);
    };
 
    [
        object,
        uuid(A498D021-CEE7-4513-AB50-38C342E2C135),
        dual,
        pointer_default(unique),
        helpcontext(0)
    ]
    interface IChangeArg : IDispatch
    {
        [propget, id(1), helpcontext(0)]
        HRESULT Item([out, retval] IDatabaseItemBase**);
        [propget, id(2), helpcontext(0)]
        HRESULT ChangeContext([out, retval] enum ChangeContext*);       
    };
 
    [
        uuid(64CD37BE-3067-4DA0-ADB2-60404E5034E1),
        helpstring("DatabaseItem events"),
        helpcontext(0)
    ]
    dispinterface _IDatabaseItemEvents
    {
    properties:
    methods:
        [id(50), helpcontext(0)]
        HRESULT OnValueChanged([in] IChangeArg* arg);
        [id(51), helpcontext(0)]
        HRESULT OnTypeChanged([in] IChangeArg* arg);
        [id(52), helpcontext(0)]
        HRESULT OnNameChanged([in] IChangeArg* arg);
        [id(53), helpcontext(0)]
        HRESULT OnDeleted([in] IChangeArg* arg);
        [id(54), helpcontext(0)]
        HRESULT OnCreated([in] IChangeArg* arg);
        [id(55), helpcontext(0)]
        HRESULT OnPropertyChanged([in] IChangeArg* arg);
        [id(56), helpcontext(0)]
        HRESULT OnTransmission([in] ITransmissionData* pTransmission);
    };
 
    [
        uuid(15A6EA11-EFD8-4E5C-AAEC-9794825B22EF),
        helpstring("DatabaseItem Class"),
        helpcontext(112)
    ]
    coclass DatabaseItem
    {
        [default] interface IDatabaseItemBase;
        [default, source] dispinterface _IDatabaseItemEvents;
    };
 
    [
        object,
        uuid(E5AEF7C5-615B-41E5-A24E-1181D24B5331),
        dual,
        helpstring("IDatabaseItemCol-Schnittstelle"),
        pointer_default(unique),
        helpcontext(113),
        hidden
    ]
    interface IDatabaseItemCol : ICol
    {
        [propget, id(DISPID_VALUE), helpstring("Eigenschaft Item"), helpcontext(114)] 
        HRESULT Item([in] VARIANT vIndex, [out, retval] IDatabaseItem**);
        [id(100), helpcontext(115)] HRESULT AddItem(IDatabaseItem* pData);
    };
 
    [
        uuid(465C6C1E-F7FA-40D9-B7F1-8CA2BFEBACD3),
        helpstring("DatabaseItemCol Class"),
        helpcontext(116)
    ]
    coclass DatabaseItemCol
    {
        [default] interface IDatabaseItemCol;
    };
 
    [
        object,
        uuid(9CDB03D2-58E8-4CF8-8F1A-F0672C9BCFD0),
        dual,
        pointer_default(unique),
        helpstring("IValue-Schnittstelle"),
        helpcontext(117)
    ]
    interface IValue : IDatabaseItem
    {
        [propget, id(DISPID_VALUE), helpcontext(118)] HRESULT Value([out, retval] VARIANT*);
        [propput, id(DISPID_VALUE), helpcontext(119)] HRESULT Value([in] VARIANT vVal);
        [propget, id(801), helpcontext(120)] HRESULT ValueType([out, retval] enum ValueType*);
        [propput, id(801), helpcontext(121)] HRESULT ValueType([in] enum ValueType enVal);
        [propget, id(802), helpcontext(122)] HRESULT ValueString([out, retval] BSTR*);
        [propput, id(802), helpcontext(123)] HRESULT ValueString([in] BSTR sVal);
        [propget, id(803), helpcontext(124), hidden] HRESULT ValueDouble([out, retval] double*);
        [propput, id(803), helpcontext(125), hidden] HRESULT ValueDouble([in] double dVal);
        [propget, id(804), helpcontext(126), hidden] HRESULT ValueInt64([out, retval] INT64*);
        [propput, id(804), helpcontext(127), hidden] HRESULT ValueInt64([in] INT64 llVal);
        [propget, id(805), helpcontext(128), hidden] HRESULT MinValueInt64([out, retval] INT64*);
        [propput, id(805), helpcontext(129), hidden] HRESULT MinValueInt64([in] INT64 llVal);
        [propget, id(806), helpcontext(130), hidden] HRESULT MaxValueDouble([out, retval] double*);
        [propput, id(806), helpcontext(131), hidden] HRESULT MaxValueDouble([in] double dVal);
        [propget, id(807), helpcontext(132)] HRESULT StartValue([out, retval] IAttribute**);
        [propget, id(808), helpcontext(133)] HRESULT StartValueActive([out, retval] IAttribute**);
        [propget, id(809), helpcontext(134)] HRESULT Minimum([out, retval] IAttribute**);
        [propget, id(810), helpcontext(135)] HRESULT Maximum([out, retval] IAttribute**);
        [propget, id(811), helpcontext(136)] HRESULT Unit([out, retval] IAttribute**);
        [propget, id(812), helpcontext(137)] HRESULT DisplayType([out, retval] IAttribute**);
        [propget, id(813), helpcontext(138)] HRESULT DisplayValueType([out, retval] IAttribute**);
        [propget, id(814), helpcontext(139)] HRESULT DecimalPlaces([out, retval] IAttribute**);
        [propget, id(815), helpcontext(140)] HRESULT ValueConversion([out, retval] enum ValueConversionType*);
        [propput, id(815), helpcontext(141)] HRESULT ValueConversion([in] enum ValueConversionType enVal);
        [propget, id(816), helpcontext(142)] HRESULT Conversion([out, retval] IConversion**);
        [propput, id(816), helpcontext(143)] HRESULT Conversion([in] IConversion* ppItem);
        [propget, id(817), helpcontext(144)] HRESULT ValueTable([out, retval] IValueTable**);
        [propput, id(817), helpcontext(145)] HRESULT ValueTable([in] IValueTable* ppItem);
        [propget, id(818), helpcontext(146)] HRESULT DataChangeEvents([out, retval] VARIANT_BOOL*);
        [propput, id(818), helpcontext(147)] HRESULT DataChangeEvents([in] VARIANT_BOOL val);
        [propget, id(819), helpcontext(148)] HRESULT Asynchron([out, retval] VARIANT_BOOL*);      
        [propput, id(819), helpcontext(149)] HRESULT Asynchron([in] VARIANT_BOOL val);  
        [propget, id(820), helpcontext(150)] HRESULT Factor([out, retval] double*);
        [propput, id(820), helpcontext(151)] HRESULT Factor([in] double newVal);
        [propget, id(821), helpcontext(152)] HRESULT Offset([out, retval] double*);
        [propput, id(821), helpcontext(153)] HRESULT Offset([in] double newVal);
        [propget, id(822), helpcontext(154)] HRESULT DisplayTypeEnum([out, retval] enum ValueDisplayType*);
        [propput, id(822), helpcontext(155)] HRESULT DisplayTypeEnum([in] enum ValueDisplayType enVal);
        [propget, id(823), helpcontext(156), hidden] HRESULT MaxValueInt64([out, retval] INT64*);
        [propput, id(823), helpcontext(157), hidden] HRESULT MaxValueInt64([in] INT64 llVal);
        [propget, id(824), helpcontext(158)] HRESULT ValuePhys([out, retval] double*);
        [propput, id(824), helpcontext(159)] HRESULT ValuePhys([in] double dVal);
        [propget, id(825), helpcontext(160)] HRESULT MinValuePhys([out, retval] double*);
        [propput, id(825), helpcontext(161)] HRESULT MinValuePhys([in] double dVal);
        [propget, id(826), helpcontext(162)] HRESULT MaxValuePhys([out, retval] double*);
        [propput, id(826), helpcontext(163)] HRESULT MaxValuePhys([in] double dVal);
        [propget, id(827), helpcontext(164), restricted] HRESULT ValueRaw64([out, retval] INT64*);
        [propput, id(827), helpcontext(165), restricted] HRESULT ValueRaw64([in] INT64 llVal);
        [propget, id(828), helpcontext(166), restricted] HRESULT MinValueRaw64([out, retval] INT64*);
        [propput, id(828), helpcontext(167), restricted] HRESULT MinValueRaw64([in] INT64 llVal);
        [propget, id(829), helpcontext(168), restricted] HRESULT MaxValueRaw64([out, retval] INT64*);
        [propput, id(829), helpcontext(169), restricted] HRESULT MaxValueRaw64([in] INT64 llVal);
        [propget, id(830), helpcontext(170)] HRESULT ValueRaw([out, retval] double*);
        [propput, id(830), helpcontext(171)] HRESULT ValueRaw([in] double dVal);
        [propget, id(831), helpcontext(172)] HRESULT MinValueRaw([out, retval] double*);
        [propput, id(831), helpcontext(173)] HRESULT MinValueRaw([in] double dVal);
        [propget, id(832), helpcontext(174)] HRESULT MaxValueRaw([out, retval] double*);
        [propput, id(832), helpcontext(175)] HRESULT MaxValueRaw([in] double dVal);
        [propput, id(833), helpcontext(174)] HRESULT ValueObject([in] IValue* pVal);
    };
   
    [
        object,
        uuid(E1E2B700-C437-42C7-93E1-0CD9C17605DE),
        dual,
        pointer_default(unique),
        helpstring("IValueItem-Schnittstelle"),
        helpcontext(176)
    ]
    interface IValueItem : IValue
    {
        [propget, id(700), helpcontext(177)] HRESULT Reference([out, retval] IValue**);
        [propput, id(700), helpcontext(178)] HRESULT Reference([in] IValue* pVal);   
    };
 
    [
        uuid(63D4F6C0-BF05-4180-85A2-B2FB2160F166),
        helpstring("_IValueItem Events"),
        helpcontext(179)
    ]
    dispinterface _IValueItemEvents
    {
    properties:
    methods:
        [id(1), helpstring("Methode OnChanged - Wird vom COM-Thread aufgerufen."), helpcontext(180)] 
        HRESULT OnChanged();
        [id(30), helpstring("Methode OnChangedSync - Wird vom Auslöser-Thread aufgerufen."), restricted, hidden, helpcontext(181)]
        HRESULT OnChangedMT();
    };
    [
        uuid(E74EC730-A1CD-40B8-9F49-DDE957019518),
        helpstring("ValueItem Class"),
        helpcontext(182)
    ]
    coclass ValueItem
    {
        [default] interface IValueItem;
        [default, source] dispinterface _IValueItemEvents;
    };
    [
        object,
        uuid(99B70E50-9964-4E14-919B-C920EE7852AF),
        dual,
        helpstring("IAttribute-Schnittstelle"),
        pointer_default(unique),
        hidden,
        helpcontext(183)
    ]
    interface IAttribute : IValue
    {
        [propget, id(701), helpstring("Eigenschaft Type"), helpcontext(184), hidden]
        HRESULT Type([out, retval] enum AttrType*);
        [propget, id(702), helpstring("Eigenschaft Min"), helpcontext(185), hidden] 
        HRESULT Min([out, retval] VARIANT*);
        [propput, id(702), helpstring("Eigenschaft Min"), helpcontext(186), hidden] 
        HRESULT Min([in] VARIANT vNewVal);
        [propget, id(703), helpstring("Eigenschaft Max"), helpcontext(187), hidden] 
        HRESULT Max([out, retval] VARIANT*);
        [propput, id(703), helpstring("Eigenschaft Max"), helpcontext(188), hidden] 
        HRESULT Max([in] VARIANT vNewVal);
        [propget, id(704), helpstring("Eigenschaft EnumTable"), helpcontext(189), hidden] 
        HRESULT EnumTable([out, retval] VARIANT*);
        [propput, id(704), helpstring("Eigenschaft EnumTable"), helpcontext(190), hidden] 
        HRESULT EnumTable([in] VARIANT vNewVal);      
        [propget, id(705), helpstring("Eigenschaft DefAttr"), helpcontext(191)]
        HRESULT DefAttr([out, retval] enum DatabaseType*);
        [propput, id(705), helpstring("Eigenschaft DefAttr"), helpcontext(192), hidden] 
        HRESULT DefAttr([in] enum DatabaseType enNewVal);      
        [propget, id(706), helpstring("Eigenschaft IsRefAttr"), helpcontext(193)]
        HRESULT IsRefAttr([out, retval] VARIANT_BOOL*);
        [propput, id(706), helpstring("Eigenschaft IsRefAttr"), helpcontext(194)] 
        HRESULT IsRefAttr([in] VARIANT_BOOL boNewVal);
        [propget, id(707), helpstring("Eigenschaft RefAttr"), helpcontext(195)]
        HRESULT RefAttr([out, retval] IAttribute**);
        [propget, id(710), helpcontext(196)] HRESULT Storeable([out, retval] VARIANT_BOOL*);
        [propput, id(710), helpcontext(197)] HRESULT Storeable([in] VARIANT_BOOL boVal);
        [propget, id(712), helpcontext(198)] HRESULT InternalAttribute([out, retval] VARIANT_BOOL*);
    };
 
    [
        uuid(00749E5B-1C1B-4865-83E1-38AD7EF234D4),
        helpstring("_IAttributeEreignisschnittstelle"),
        hidden,
        helpcontext(279)
    ]
    dispinterface _IAttributeEvents
    {
    properties:
    methods:
        [id(1), helpstring("Methode OnChanged - Wird vom COM-Thread aufgerufen."), helpcontext(280)]
        HRESULT OnChanged();
        [id(30), helpstring("Methode OnChangedSync - Wird vom Auslöser-Thread aufgerufen."), restricted,  hidden, helpcontext(281)]
        HRESULT OnChangedSync();
    };
 
    [
        uuid(11DA2C02-0F64-43A3-AEDD-F660D2D920DF),
        helpstring("Attr Class"),
        helpcontext(825)
    ]
    coclass Attr
    {
        [default] interface IAttribute;
        [default, source] dispinterface _IAttributeEvents;
    };
 
    [
        object,
        uuid(DD835A29-7F36-4609-9003-EB1F9E0F4518),
        dual,
        pointer_default(unique),
        helpstring("IConversion-Schnittstelle"),
        helpcontext(199),
        hidden
    ]
    interface IConversion : IDatabaseItem
    {
        [id(800), helpcontext(200)] HRESULT ConvertToPhys([in] INT64 llRaw, [out, retval] double*);
        [id(801), helpcontext(201)] HRESULT ConvertToHex([in] double dVal, [out, retval] INT64*);
    };
 
    [
        object,
        uuid(B2E3FE78-B3AB-4780-8EBA-A90B995A13E9),
        dual,
        pointer_default(unique),
        helpstring("IOffsetFactorConversion-Schnittstelle"),
        helpcontext(202)
    ]
    interface IOffsetFactorConversion : IConversion
    {
        [propget, id(700), helpcontext(203)] HRESULT Factor([out, retval] IAttribute**);
        [propget, id(701), helpcontext(204)] HRESULT Offset([out, retval] IAttribute**);
    };
 
    [
        uuid(34ECB60F-A007-454D-A80E-89382FDE7F5B),
        helpstring("OffsetFactorConversion Class"),
        helpcontext(205)
    ]
    coclass OffsetFactorConversion
    {
        [default] interface IOffsetFactorConversion;
    };
 
    coclass TransmissionData;
 
    [
        object,
        uuid(6A878EDC-E00E-4847-AE5A-62713E4625BE),
        dual,
        helpstring("ITransmissionEvent-Schnittstelle"),
        pointer_default(unique),
        helpcontext(206)
    ]
    interface ITransmissionEvent : IDispatch
    {
        [propget, id(DISPID_VALUE), helpstring("Eigenschaft Active"), helpcontext(207)]
        HRESULT Active([out, retval] VARIANT_BOOL*);
        [propput, id(DISPID_VALUE), helpstring("Eigenschaft Active"), helpcontext(208)]
        HRESULT Active([in] VARIANT_BOOL boNewVal);
        [propget, id(10), helpstring("Eigenschaft Filter"), helpcontext(209)]
        HRESULT Filter([out, retval] BSTR*);
        [propput, id(10), helpstring("Eigenschaft Filter"), helpcontext(210)] 
        HRESULT Filter([in] BSTR pFilter);
      
        [propget, id(20), helpstring("Eigenschaft Position"), hidden, helpcontext(211)]
        HRESULT Position([out, retval] enum CallbackPosition*);
        [propput, id(20), helpstring("Eigenschaft Position"), hidden, helpcontext(212)] 
        HRESULT Position([in] enum CallbackPosition enPosition);
      
        [propget, id(30), helpstring("Eigenschaft Id"), hidden, helpcontext(213)]
        HRESULT Id([out, retval] BSTR*);
        [propput, id(30), helpstring("Eigenschaft Id"), hidden, helpcontext(214)] 
        HRESULT Id([in] BSTR sStrId);
      
        [propget, id(40), helpstring("Eigenschaft Object"), helpcontext(215)]
        HRESULT Object([out, retval] IDatabaseItem**);
        [propput, id(40), helpstring("Eigenschaft Object"), helpcontext(216)] 
        HRESULT Object([in] IDatabaseItem *pData);
 
        [propget, id(50), helpstring("Eigenschaft Asynchron"), helpcontext(217)]
        HRESULT Asynchron([out, retval] VARIANT_BOOL*);
        [propput, id(50), helpstring("Eigenschaft Asynchron"), helpcontext(218)]
        HRESULT Asynchron([in] VARIANT_BOOL boNewVal);
 
        [propget, id(60), helpstring("Eigenschaft Direction"), helpcontext(219)]
        HRESULT DirectionFilter([out, retval] enum DirectionFilter*);
        [propput, id(60), helpstring("Eigenschaft Direction"), helpcontext(220)]
        HRESULT DirectionFilter([in] enum DirectionFilter enNewVal);
    };
 
    [
        uuid(8D61B3FF-DE3C-4AA9-A9E9-942906B6092D),
        helpstring("_ITransmissionEventEreignisschnittstelle"),
        helpcontext(0)
    ]
    dispinterface _ITransmissionEventEvents
    {
    properties:
    methods:
        [id(14), helpcontext(293)]  HRESULT OnTransmission([in] TransmissionData* pTransmission);
        [id(35), restricted, hidden, helpcontext(299)]  HRESULT OnTransmissionMT([in] TransmissionData* pTransmission);
    };
 
    [
        uuid(52728547-43AB-4AE0-A150-F1D99134DD7A),
        helpstring("TransmissionEvent Class"),
        helpcontext(221)
    ]
    coclass TransmissionEvent
    {
        [default] interface ITransmissionEvent;
        [default, source] dispinterface _ITransmissionEventEvents;
    };
 
    [
        object,
        uuid(6282F2DA-0FCD-48C8-A821-F0BF843CA2BD),
        dual,
        helpstring("IValueTableEntry-Schnittstelle"),
        pointer_default(unique)
    ]
    interface IValueTableEntry : IDispatch
    {
        [propget, id(DISPID_VALUE), helpstring("Property Entry Description"), helpcontext(0)]
        HRESULT EntryDescription([out, retval] BSTR*);
        [propput, id(DISPID_VALUE), helpcontext(0)]
        HRESULT EntryDescription([in] BSTR desc);
        [propget, id(2), helpstring("Property Entry Value From"), helpcontext(0)]
        HRESULT EntryValueFrom([out, retval] long*);
        [propput, id(2), helpcontext(0)]
        HRESULT EntryValueFrom([in] long val);
        [propget, id(3), helpstring("Property Entry Value To"), helpcontext(0)]
        HRESULT EntryValueTo([out, retval] long*);
        [propput, id(3), helpcontext(0)]
        HRESULT EntryValueTo([in] long val);
    };
   
    [
        uuid(5CC697AB-9AC1-4B40-B696-17812253543B),
        helpstring("ValueTableEntry Class"),
        helpcontext(0)
    ]
    coclass ValueTableEntry
    {
        [default] interface IValueTableEntry;
    };
 
    [
        object,
        uuid(61C34C3E-95CA-4F73-8227-D5DB5F6AB66A),
        dual,
        helpstring("IValueTableEntryCol-Schnittstelle"),
        pointer_default(unique)
    ]
    interface IValueTableEntryCol : ICol
    {
        [propget, id(DISPID_VALUE), helpstring("Eigenschaft Item"), helpcontext(0)]
        HRESULT Item([in] VARIANT vIndex, [out, retval] IValueTableEntry**);
        [id(10), helpstring("Eigenschaft AddValueTableEntry"), helpcontext(0)]
        HRESULT AddValueTableEntry([in] BSTR sDescription, [in] long nValueFrom, [in] long nValueTo, [out, retval] IValueTableEntry**);
        [id(20), helpstring("Eigenschaft AddItem"), helpcontext(0)]
        HRESULT AddItem(IValueTableEntry* pEntry);
        [id(30), helpstring("Methode Delete"), helpcontext(0)]
        HRESULT Delete([in] long nIndex);
    };
 
    [
        uuid(13A1C1CC-E028-40F5-9A07-B3ED70BAF821),
        helpstring("ValueTableEntryCol Class"),
        helpcontext(0)
    ]
    coclass ValueTableEntryCol
    {
        [default] interface IValueTableEntryCol;
    };
 
    [
        object,
        uuid(788BCF5D-4E6F-4E10-9F43-430AEB6A01BE),
        dual,
        helpstring("IValueTable-Schnittstelle"),
        pointer_default(unique),
        helpcontext(222)
    ]
    interface IValueTable : IDatabaseItem
    {
        [propget, id(5), helpstring("Eigenschaft Entry"), helpcontext(223), hidden]
        HRESULT Entry([in] long nIndex, [out, retval] struct ValueEntry*);
        [propget, id(6), helpstring("Eigenschaft Count"), helpcontext(224)]
        HRESULT Count([out, retval] LONG*);
        [id(7), helpstring("Methode Add"), helpcontext(225), hidden]
        HRESULT Add([in] struct ValueEntry* pEntry, [out,retval] LONG*);
        [propget, id(8), helpstring("Eigenschaft TableEntry"), helpcontext(223)]
        HRESULT TableEntry([in] long nIndex, [out, retval] struct ValueRangeEntry*);
        [id(9), helpstring("Methode Insert"), helpcontext(225)]
        HRESULT Insert([in] struct ValueRangeEntry* pEntry, [out, retval] LONG*);
        [propget, id(10), helpstring("Eigenschaft TableEntries"), helpcontext(0)]
        HRESULT TableEntries([out, retval] IValueTableEntryCol**);
    };
 
    [
        uuid(1B5D505E-9570-4B4A-8576-D8CC2BA9F35D),
        helpstring("ValueTable Class"),
        helpcontext(831)
    ]
    coclass ValueTable
    {
        [default] interface IValueTable;
    };
 
    [
        object,
        uuid(D3D94DF4-B5F2-42A7-A0EE-DC6A1753AC99),
        dual,
        nonextensible,
        helpstring("IValueTableCol-Schnittstelle"),
        pointer_default(unique),
        helpcontext(226)
    ]
    interface IValueTableCol : IDispatch
    {
        [propget, id(DISPID_VALUE), helpstring("Eigenschaft Item"), helpcontext(227)]
        HRESULT Item([in] VARIANT vIndex, [out, retval] IValueTable**);
        [propget, id(DISPID_NEWENUM), helpstring("Eigenschaft _NewEnum"), restricted, hidden, helpcontext(228)] //VSTAHidden
        HRESULT _NewEnum([out, retval] IUnknown**); 
        [id(1), helpstring("Methode Delete"), helpcontext(229)]
        HRESULT Delete([in] VARIANT vIndex);
        [id(2), helpstring("Methode AddValueTable"), helpcontext(230)]
        HRESULT AddValueTable([in] BSTR sName, [out,retval] IValueTable** );
        [propget, id(3), helpcontext(231)]
        HRESULT Count([out,retval] long*);
    };
 
    [
        uuid(F27A9974-A12B-4C55-8047-717A06CA08CA),
        helpstring("ValueTableCol Class"),
        helpcontext(832)
    ]
    coclass ValueTableCol
    {
        [default] interface IValueTableCol;
 
        // BTP#2952, BTP#2913: COM interface error information
        interface ISupportErrorInfo;
    };
 
   interface ISelection;
 
   //
   //       SchedulerTable
   //
 
    [
        object,
        uuid(2613E23A-47C7-4087-9F7B-D0B6472B584A),
        dual,
        nonextensible,
        pointer_default(unique),
        helpcontext(232)
    ]
    interface ISchedulerTable : IDatabaseItem
    {
        [id(10), helpcontext(233)]
            HRESULT Execute();
        [id(11), helpcontext(0)]
            HRESULT Stop();
        [propget, id(12), helpstring("Eigenschaft Type"), helpcontext(0)]
            HRESULT Active([out, retval] VARIANT_BOOL* active);
        [propput, id(12), helpstring("Eigenschaft Type"), helpcontext(0)]
            HRESULT Active([in] VARIANT_BOOL active);
    };
 
    [
        uuid(ABB134DC-15E8-4D1F-AE86-2DB353E91BF3),
        helpstring("SchedulerTable Class"),
        helpcontext(234)
    ]
    coclass SchedulerTable
    {
        [default] interface ISchedulerTable;
    };
 
 
   //
   //       EnvVar
   //
 
   interface IEnvVarCol;
 
    [
        uuid(63C5B25E-2E9C-4760-B2A5-62402A27BCA3),
        helpstring("_IEnvVarEreignisschnittstelle"),
        helpcontext(235)
    ]
    dispinterface _IEnvVarEvents
    {
    properties:
    methods:
        [id(1), helpstring("Methode OnChanged - Wird vom COM-Thread aufgerufen."), helpcontext(236)]
        HRESULT OnChanged();
        [id(30), helpstring("Methode OnChangedSync - Wird vom Auslöser-Thread aufgerufen."), restricted, hidden, helpcontext(237)]
        HRESULT OnChangedSync();
    };
 
    [   
        object,
        uuid(245B8025-5C32-4c7f-9952-6EEC29799435),
        dual,
        helpstring("IEnvVar-Schnittstelle"),
        pointer_default(unique),
        helpcontext(238)
    ]
    interface IEnvVar : IValue
    {
        [id(6), helpstring("Methode Notify"), helpcontext(239)] 
        HRESULT Notify(void);
        [propget, id(11), helpstring("Eigenschaft Type"), helpcontext(240)]
        HRESULT Type([out, retval] enum EnvVarType*);
        [propput, id(11), helpstring("Eigenschaft Type"), helpcontext(241)]
        HRESULT Type([in] enum EnvVarType enType);
        [propget, id(12), helpstring("Eigenschaft Array"), helpcontext(242)]
        HRESULT Array([out, retval] VARIANT_BOOL*);
        [propput, id(12), helpstring("Eigenschaft Array"), helpcontext(243)]
        HRESULT Array([in] VARIANT_BOOL boVal); 
        [id(18), helpstring("Methode ReplaceValue"), helpcontext(244)]
        HRESULT ReplaceValue([in] VARIANT vVal);
        [id(19), helpstring("Methode GetString"), helpcontext(245)]
        HRESULT GetString([out, retval] BSTR*);
    };
 
 
    [
        uuid(0372AC28-2185-4692-8B31-C8EF0A22B8FE),
            helpstring("EnvVar Class"),
            helpcontext(250)
    ]
    coclass EnvVar
    {
        [default] interface IEnvVar;
        [default, source] dispinterface _IEnvVarEvents;
    };
 
    [   
        object,
        uuid(296D059A-A79F-4637-91E6-9DA69E3F74C1),
        dual,
        helpstring("IEnvVarCol-Schnittstelle"),
        pointer_default(unique),
        helpcontext(246)
    ]
    interface IEnvVarCol : ICol
    {
        [propget, id(DISPID_VALUE), helpstring("Eigenschaft Item"), helpcontext(247)]
        HRESULT Item([in] VARIANT vIndex, [out, retval] IEnvVar**);      
        [id(5), helpstring("Methode AddEnvVar"), helpcontext(248)]
        HRESULT AddEnvVar([in] BSTR sName, [out, retval] IEnvVar**); 
        [id(100), helpcontext(249)] HRESULT AddItem(IDatabaseItem* pData);
    };
 
    [
        uuid(2AD1FCC1-F804-4c16-9E75-CA0D85DBADF7),
        helpstring("EnvVarCol Class"),
        helpcontext(251)
    ]
    coclass EnvVarCol
    {
        [default] interface IEnvVarCol;
    };
 
 
    //
    //       Namespace
    //
 
    interface INamespaceCol;
 
    [   
        object,
        uuid(D94AF6D3-6591-4603-A0C1-4E481358937E),
        dual,
        helpstring("INamespace-Schnittstelle"),
        pointer_default(unique),
        helpcontext(252)
    ]
    interface INamespace : IDatabaseItem
    {
        [id(6), helpstring("Methode Notify"), helpcontext(253)]
        HRESULT Notify(void);
        [propget, id(9), helpstring("Property EnvVars"), helpcontext(254)]
        HRESULT EnvVars([out, retval] IEnvVarCol**); 
    };
 
    [
        uuid(F891D61C-504E-4851-BB14-7E3886ACD93B),
        helpstring("Namespace Class"),
        helpcontext(275)
    ]
    coclass Namespace
    {
        [default] interface INamespace;
    };
 
 
    [   
        object,
        uuid(B0C051F8-D34A-462b-B0F9-9E703755DF0D),
        dual,
        helpstring("INamespaceCol-Schnittstelle"),
        pointer_default(unique),
        helpcontext(255)
    ]
    interface INamespaceCol : ICol
    {
        [propget, id(DISPID_VALUE), helpstring("Eigenschaft Item"), helpcontext(256)] 
        HRESULT Item([in] VARIANT vIndex, [out, retval] INamespace**);
        [id(5), helpstring("Methode AddNamespace"), helpcontext(257)]
        HRESULT AddNamespace([in] BSTR sName, [out, retval] INamespace**);
        [id(100), helpcontext(258)] HRESULT AddItem(IDatabaseItem* pData);
    };
 
    [
        uuid(C793BA00-961E-46d1-8F6C-805F1EE5BC21),
        helpstring("NamespaceCol Class"),
        helpcontext(276)
    ]
    coclass NamespaceCol
    {
        [default] interface INamespaceCol;
    };
 
    [   
        object,
        uuid(F8CD9E3C-3605-4003-8398-98E08A93A088),
        dual,
        helpstring("IEnvVarDatabase-Schnittstelle"),
        pointer_default(unique),
        helpcontext(259)
    ]
    interface IEnvVarDatabase : INamespaceCol
    {     
        [id(7), helpstring("Methode BeginChange"), hidden]
        HRESULT BeginChange();
        [id(8), helpstring("Methode EndChange"), hidden]
        HRESULT EndChange();
        [propget, id(9), helpstring("Eigenschaft BeginEndChangeEvents"), hidden, helpcontext(260)] 
        HRESULT BeginEndChangeEvents([out, retval] VARIANT_BOOL*);
        [propput, id(9), helpstring("Eigenschaft BeginEndChangeEvents"), hidden, helpcontext(261)] 
        HRESULT BeginEndChangeEvents([in] VARIANT_BOOL boActive);
        [id(10), helpstring("Methode GetObjectByStringRef"), helpcontext(262)]
        HRESULT GetObjectByStringRef([in] BSTR sText, [out, retval] IDatabaseItem**);
        [id(11), helpstring("Methode Notify"), helpcontext(263)]
        HRESULT Notify(void);
        [propget, id(12), helpstring("Eigenschaft ValueChangeEvents"), helpcontext(264)] 
        HRESULT ValueChangeEvents([out, retval] VARIANT_BOOL*);      
        [propput, id(12), helpstring("Eigenschaft ValueChangeEvents"), helpcontext(265)] 
        HRESULT ValueChangeEvents([in] VARIANT_BOOL boActive);            
        [propget, id(13), helpcontext(266)]  HRESULT Namespaces([out, retval] INamespaceCol**);
        [propget, id(14), helpcontext(267)]  HRESULT EnvVars([out, retval] IEnvVarCol**);
    };
 
    [
        uuid(3E80CA97-EEBC-4462-9413-5D52088A053C),
        helpstring("IEnvVarDatabase-Ereignisschnittstelle"),
        helpcontext(268)
    ]
    dispinterface _IEnvVarDatabaseEvents
    {
    properties:
    methods:
        [id(30), helpstring("Methode OnValueChanged"), helpcontext(269)]
        HRESULT OnValueChanged([in] EnvVar* pVar);   
        [id(31), helpstring("Methode OnValueChangedSync"), restricted, hidden, helpcontext(270)]
        HRESULT OnValueChangedSync([in] EnvVar* pVar);   
 
        [id(40), helpstring("Methode OnBeginChange"), hidden, helpcontext(271)]
        HRESULT OnBeginChange();
        [id(41), helpstring("Methode OnBeginChangeSync"), restricted,  hidden, helpcontext(272)]
        HRESULT OnBeginChangeSync();
        [id(42), helpstring("Methode OnEndChange"), hidden, helpcontext(273)]
        HRESULT OnEndChange();
        [id(43), helpstring("Methode OnEndChangeSync"), restricted, hidden, helpcontext(274)]
        HRESULT OnEndChangeSync();      
    };
 
    [
        uuid(8AEEDEF0-DF96-4ecf-9E37-46D4371C08C3),
        helpstring("EnvVarDB Class"),
        helpcontext(277)
    ]
    coclass EnvVarDatabase
    {
        [default] interface IEnvVarDatabase;
        [default, source] dispinterface _IEnvVarDatabaseEvents;
    };
 
 
 
 
    [
        object,
        uuid(D1B186BA-EECA-4510-AB9B-F558B443E051),
        dual,
        helpstring("IAttrCol-Schnittstelle"),
        pointer_default(unique),
        hidden,
        helpcontext(282)
    ]
    interface IAttrCol : ICol
    {
        [propget, id(DISPID_VALUE), helpstring("Eigenschaft Item"), helpcontext(283)]
        HRESULT Item([in] VARIANT vIndex, [out, retval] IAttribute**);
        [id(7), helpstring("Methode AddAttr"), helpcontext(284)]
        HRESULT AddAttr([in] BSTR sName, [in] enum AttrType enType, [in] VARIANT vValue, [out, retval] IAttribute**);
 
        [id(8), helpstring("Methode AddEnumAttr"), hidden /*, helpcontext(285)*/]
        HRESULT AddEnumAttr([in] BSTR sName, [in] VARIANT vEnum, [in] long lVal, [out, retval] IAttribute**);
        [id(100), helpcontext(286)] HRESULT AddItem(IDatabaseItem* pData);
    };
 
    [
        uuid(EA0931D0-2647-4C40-8194-4BD856E0D048),
        helpstring("AttrCol Class"),
        helpcontext(824)
    ]
    coclass AttrCol
    {
        [default] interface IAttrCol;
    };
 
 
    [
        object,
        uuid(4A9764EF-7DFE-4E59-AB3A-C5E0D2B80795),
        dual,
        pointer_default(unique),
        helpcontext(0)
    ]
    interface IDTC : IDatabaseItem
    {
        [propget, id(10), helpcontext(0)]
        HRESULT Code([out, retval] long* lCode);
 
        [propget, id(11), helpcontext(0)]
         HRESULT Display([out, retval] BSTR* display);
 
        [propget, id(12), helpcontext(0)]
        HRESULT Level([out, retval] long* level);
    };
 
    [
        uuid(695AE643-F371-40CC-9AAF-50F21FCB5F23),
        helpcontext(0)
    ]
    coclass DTC
    {
        [default] interface IDTC;
    };
 
    [
        object,
        uuid(4A9764EF-7DFE-4E59-AB3A-C5E0D2B80796),
        dual,
        pointer_default(unique),
        helpcontext(0)
    ]
    interface IDTCCol : ICol
    {
        [propget, id(DISPID_VALUE), helpcontext(0)]
        HRESULT Item([in] VARIANT vIndex, [out, retval] IDTC**);
    };
 
    [
        uuid(695AE643-F371-40CC-9AAF-50F21FCB5F22),
        helpcontext(0)
    ]
    coclass DTCCol
    {
        [default] interface IDTCCol;
    };
 
    [
        object,
        uuid(4A9764EF-7DFE-4E59-AB3A-C5E0D2B80794),
        dual,
        pointer_default(unique),
        helpcontext(0)
    ]
    interface IDTCContainer : IValue
    {
        [id(10)] HRESULT GetDTCByName([in]BSTR key, [out, retval] IDTC** dtc);
        [id(11)] HRESULT GetDTCByDisplay([in]BSTR key, [out, retval] IDTC** dtc);
        [id(12)] HRESULT GetDTCByCode([in]long key, [out, retval] IDTC** dtc);
        [id(13)] HRESULT GetDTCByDesc([in]BSTR key, [out, retval] IDTC** dtc);        
        [propget, id(14)] HRESULT DTCs([out, retval] IDTCCol** dtcs);
    };
 
    [
        uuid(695AE643-F371-40CC-9AAF-50F21FCB5F21),
        helpcontext(0)
    ]
    coclass DTCContainer
    {
        [default] interface IDTCContainer;
    };
 
    [
        object,
        uuid(46447F3C-46EA-4C80-9ED9-06E44278747D),
        dual,
        pointer_default(unique),
        helpcontext(0)
    ]
    interface IDataEntryBase : IValue
    {
        [propget, id(10), helpstring("Eigenschaft DataEntrys"), helpcontext(0)]
        HRESULT Type([out, retval] enum DataEntryType*);
        [propget, id(11), helpstring("Eigenschaft ValueHex"), helpcontext(305)]
        HRESULT ValueHex([out, retval] VARIANT*);
        [propput, id(11), helpstring("Eigenschaft ValueHex"), helpcontext(306)]
        HRESULT ValueHex([in] VARIANT vData);
    };
 
    [
        object,
        uuid(4F29503F-8E51-4AA9-AD1E-594020946CA9),
        dual,
        helpstring("IStaticDataEntry-Interface"),
        pointer_default(unique),
        helpcontext(0)
    ]
    interface IStaticDataEntryBase : IDataEntryBase
    {
        [propget, id(16), helpstring("Eigenschaft Bitlength"), helpcontext(310)]
        HRESULT Bitlength([out, retval] short*);
        [propput, id(16), helpstring("Eigenschaft Bitlength"), helpcontext(310)]
        HRESULT Bitlength([in] short pVal);
        [propget, id(17), helpstring("Eigenschaft StartBit"), helpcontext(311)]
        HRESULT StartBit([out, retval] short*);
        [propput, id(17), helpstring("Eigenschaft StartBit"), helpcontext(311)]
        HRESULT StartBit([in] short val);
        [propget, id(22), helpstring("Eigenschaft ByteOrder"), helpcontext(315)]
        HRESULT ByteOrder([out, retval] enum ByteOrder*);
        [propput, id(22), helpstring("Eigenschaft ByteOrder"), helpcontext(315)]
        HRESULT ByteOrder([in] enum ByteOrder val);
 
        [propget, id(28), helpstring("Eigenschaft StartBitMotorola"), helpcontext(0)]
            HRESULT StartBitMotorola([out, retval] short*);
        [propput, id(28), helpstring("Eigenschaft StartBitMotorola"), helpcontext(0)]
            HRESULT StartBitMotorola([in] short val);
 
    };
   
    interface IDataEntryColBase;
    interface IDataEntryColOfStatic;
    interface IDataEntryColOfDynamic;
       
    [
        object,
        uuid(D5971925-1468-460A-B501-7A0EAB38E5B8),
        dual,
        helpstring("IStaticDataEntry-Interface"),
        pointer_default(unique),
        helpcontext(0)
    ]
    interface IStaticDataEntry : IStaticDataEntryBase
    {
        [propget, id(12), helpstring("Eigenschaft DataEntrys"), helpcontext(0)]
        HRESULT DataEntrys([out, retval] IDataEntryColOfStatic**);
    };
 
    [
        object,
        uuid(E3EBCB8E-6C9A-44B0-9387-6AA3D6CA0083),
        dual,
        helpstring("IDynamicDataEntry-Interface"),
        pointer_default(unique),
        helpcontext(0)
    ]
    interface IDynamicDataEntryBase : IDataEntryBase
    {
        [propget, id(16), helpstring("Eigenschaft Bitlength"), helpcontext(310)]
        HRESULT Bytelength([out, retval] short*);
        [propput, id(16), helpstring("Eigenschaft Bitlength"), helpcontext(310)]
        HRESULT Bytelength([in] short pVal);
        [propget, id(17), helpstring("Eigenschaft StartBit"), helpcontext(311)]
        HRESULT StartByte([out, retval] short*);
        [propput, id(17), helpstring("Eigenschaft StartBit"), helpcontext(311)]
        HRESULT StartByte([in] short val);
        [propget, id(22), helpstring("Eigenschaft ByteOrder"), helpcontext(315)]
        HRESULT ByteOrder([out, retval] enum ByteOrder*);
        [propput, id(22), helpstring("Eigenschaft ByteOrder"), helpcontext(315)]
        HRESULT ByteOrder([in] enum ByteOrder val);
    };
   
    [
        object,
        uuid(0D746D7F-1396-41B1-AB2E-CB7FE3DB1954),
        dual,
        helpstring("IDynamicDataEntry-Interface"),
        pointer_default(unique),
        helpcontext(0)
    ]
    interface IDynamicDataEntry : IDynamicDataEntryBase
    {
        [propget, id(12), helpstring("Eigenschaft DataEntrys"), helpcontext(0)]
        HRESULT DataEntrys([out, retval] IDataEntryColOfDynamic**);
        [id(13), helpcontext(0)] HRESULT ReadData();
        [id(14), helpcontext(0)] HRESULT WriteData();
    };
 
    [
        uuid(0F88BB27-F155-44E6-8D04-151BBA898856),
        helpstring("_IDataEntryBaseEreignisschnittstelle"),
        helpcontext(0)
    ]
    dispinterface _IDataEntryBaseEvents
    {
    properties:
    methods:
        [id(1), helpstring("Methode OnChanged - Wird vom COM-Thread aufgerufen."), helpcontext(288)]
        HRESULT OnChanged();
        [id(30), helpstring("Methode OnChangedSync - Wird vom Auslöser-Thread aufgerufen."), restricted, hidden, helpcontext(355)]
        HRESULT OnChangedSync();
    };
 
    [
        object,
        uuid(F71BD47B-8F06-4C45-8A26-B0BAB673A774),
        dual,
        helpstring("IDataArray-Interface"),
        nonextensible,
        pointer_default(unique),
        helpcontext(0)
    ]
    interface IDataArray : IDynamicDataEntryBase
    {
        [propget, id(1), helpstring("Eigenschaft ArrayElemBytelength"), helpcontext(0)]
        HRESULT ArrayElemBytelength([out, retval] short*);
        [propget, id(2), helpstring("Eigenschaft ArrayElemNo"), helpcontext(0)]
        HRESULT ArrayElemNo([out, retval] short*);
        [propput, id(2), helpstring("Eigenschaft ArrayElemNo"), helpcontext(0)]
        HRESULT ArrayElemNo([in] short val);
        [propget, id(3), helpstring("Eigenschaft ArrayElemCount"), helpcontext(0)]
        HRESULT ArrayElemCount([out, retval] short*);
        [propget, id(4), helpstring("Eigenschaft ArrayElemValueHex"), helpcontext(0)]
        HRESULT ArrayElemValueHex([out, retval] VARIANT *vData);
        [propput, id(4), helpstring("Eigenschaft ArrayElemValueHex"), helpcontext(0)]
        HRESULT ArrayElemValueHex([in] VARIANT vData);
        [propget, id(12), helpstring("Eigenschaft DataEntrys"), helpcontext(0)]
        HRESULT DataEntrys([out, retval] IDataEntryColOfStatic**);
    };
 
    [
        uuid(76C6BA89-7863-45BE-8ACB-BAC7CF2E3460),
        helpstring("DataArray Class"),
        helpcontext(0)
    ]
    coclass DataArray
    {
        [default] interface IDataArray;
        [default, source] dispinterface _IDataEntryBaseEvents;
    };
 
    [
        uuid(BCDBFA42-0060-4A21-A5FD-DBB5704593AF),
        helpstring("DataEntry Class"),
        helpcontext(0)
    ]
    coclass StaticDataEntry
    {
        [default] interface IStaticDataEntry;
        [default, source] dispinterface _IDataEntryBaseEvents;
    };
 
    [
        uuid(D3135EB4-307F-42EF-9CD0-950559DD2CC3),
        helpstring("DataEntry Class"),
        helpcontext(0)
    ]
    coclass DynamicDataEntry
    {
        [default] interface IDynamicDataEntry;
        [default, source] dispinterface _IDataEntryBaseEvents;
    };
 
    [
        object,
        uuid(21CEED19-79E8-491E-801A-91A4044D1733),
        dual,
        helpstring("IDataEntryColBase-Schnittstelle"),
        pointer_default(unique),
        helpcontext(0),
        hidden
    ]
    interface IDataEntryColBase : ICol
    {
        [propget, id(DISPID_VALUE), helpstring("Eigenschaft Item"), helpcontext(114)]
        HRESULT Item([in] VARIANT vIndex, [out, retval] IDataEntryBase**);
    };
 
    [
        object,
        uuid(B0803D3D-3657-4C56-8268-240B56D3001A),
        dual,
        helpstring("IDataEntryColOfStatic-Schnittstelle"),
        pointer_default(unique),
        helpcontext(0),
        hidden
    ]
    interface IDataEntryColOfStatic : IDataEntryColBase
    {
        [id(2), helpstring("Methode AddStaticDataEntry"), helpcontext(0)]
        HRESULT AddStaticDataEntry([in] BSTR bstrStackName, [in] long lStartBits, [in] long lBitCount, [in] enum ByteOrder enByteOrder, [out, retval] IStaticDataEntry**);
    };
 
    [
        object,
        uuid(6E567E8A-5AE8-4F26-9BDF-D7C6ADBAFF02),
        dual,
        helpstring("IDataEntryColOfDynamic-Schnittstelle"),
        pointer_default(unique),
        helpcontext(0),
        hidden
    ]
    interface IDataEntryColOfDynamic : IDataEntryColBase
    {
        [id(2), helpstring("Methode AddStaticDataEntry"), helpcontext(0)]
        HRESULT AddStaticDataEntry([in] BSTR sName, [in] long lStartBit, [in] long lBitCount, [in] enum ByteOrder enByteOrder, [out, retval] IStaticDataEntry**);
        [id(4), helpstring("Methode AddDynamicDataEntry"), helpcontext(0)]
        HRESULT AddDynamicDataEntry([in] BSTR sName, [in] long lStartByte, [in] long lByteCount, [in] enum ByteOrder enByteOrder, [out, retval] IDynamicDataEntry**);
        [id(5), helpstring("Methode AddArray("), helpcontext(0)]
        HRESULT AddArray([in] BSTR sName, [in] long lStartByte, [in] long lByteCount, [in] enum ByteOrder enByteOrder, [in] long lArrayElemByteCount, [out, retval] IDataArray**);
    };
   
    [
        uuid(BE70B498-8AA5-446C-897D-E9C6DCB507BC),
        helpstring("DataEntryColOfStatic Class"),
        helpcontext(0)
    ]
    coclass DataEntryColOfStatic
    {
        [default] interface IDataEntryColOfStatic;
    };
 
    [
        uuid(C148A2D2-9047-4113-ABB9-683A766A12C7),
        helpstring("DataEntryColOfDynamic Class"),
        helpcontext(0)
    ]
    coclass DataEntryColOfDynamic
    {
        [default] interface IDataEntryColOfDynamic;
    };
   
   interface IPreTransmit;
   interface IPreCopy;
   interface ITxConfirm;
   interface IRxConfirm;
   interface ITransmissionData;
   coclass TransmissionData;
 
    [
        uuid(F99A0016-C982-472D-BD22-D9C91CA357B3),
        helpstring("_ISignalEreignisschnittstelle"),
        helpcontext(287)
    ]
    dispinterface _ISignalEvents
    {
    properties:
    methods:
        [id(1), helpstring("Methode OnChanged - Wird vom COM-Thread aufgerufen."), helpcontext(288)] 
        HRESULT OnChanged();
        [id(10), helpstring("Methode OnPreTransmit - Wird vom COM-Thread aufgerufen."), helpcontext(289)]
        HRESULT OnPreTransmit([in] TransmissionData* pTransmission, [in] BoolValue* pAllowSend);
        [id(11), helpstring("Methode OnPreCopy - Wird vom COM-Thread aufgerufen."), helpcontext(290)]
        HRESULT OnPreCopy([in] TransmissionData* pTransmission, [out] BoolValue* pAllowCopy);
        [id(12), helpstring("Methode OnTxConfirm - Wird vom COM-Thread aufgerufen."), hidden, helpcontext(291)]
        HRESULT OnTxConfirm([in] TransmissionData* pTransmission);
        [id(13), helpstring("Methode OnRxConfirm - Wird vom COM-Thread aufgerufen."), hidden, helpcontext(292)]
        HRESULT OnRxConfirm([in] TransmissionData* pTransmission);
        [id(14), helpcontext(293)]  HRESULT OnTransmission([in] TransmissionData* pTransmission);
        [id(30), helpstring("Methode OnChangedSync - Wird vom Auslöser-Thread aufgerufen."), restricted, hidden, helpcontext(294)]
        HRESULT OnChangedSync();
        [id(31), helpstring("Methode OnPreTransmitSync - Wird vom Auslöser-Thread aufgerufen."), restricted, hidden, helpcontext(295)]
        HRESULT OnPreTransmitSync([in] TransmissionData* pTransmission, [in] BoolValue* pAllowSend);
        [id(32), helpstring("Methode OnPreCopySync - Wird vom Auslöser-Thread aufgerufen."), restricted, hidden, helpcontext(296)]
        HRESULT OnPreCopySync([in] TransmissionData* pTransmission, [out] BoolValue* pAllowCopy);
        [id(33), helpstring("Methode OnTxConfirmSync - Wird vom Auslöser-Thread aufgerufen."), restricted, hidden, helpcontext(297)]
        HRESULT OnTxConfirmSync([in] TransmissionData* pTransmission);
        [id(34), helpstring("Methode OnRxConfirmSync - Wird vom Auslöser-Thread aufgerufen."), restricted, hidden, helpcontext(298)]
        HRESULT OnRxConfirmSync([in] TransmissionData* pTransmission);
        [id(35), restricted, helpcontext(299)]  HRESULT OnTransmissionMT([in] TransmissionData* pTransmission);
    };
 
    // Vorwärtsdeklaration
    interface IReceiverCol;
 
    [
        object,
        uuid(1A646E1B-3227-4F32-A104-86EF5E94799D),
        dual,
        helpstring("ISignal-Schnittstelle"),
        pointer_default(unique),
        hidden,
        helpcontext(300)
    ]
    interface ISignal : IStaticDataEntryBase
    {
        [propget, id(8), helpstring("Eigenschaft Min"), helpcontext(301)]
        HRESULT Min([out, retval] double *pVal);
        [propput, id(8), helpstring("Eigenschaft Min"), helpcontext(302)]
        HRESULT Min([in] double dNewVal);
        [propget, id(9), helpstring("Eigenschaft Max"), helpcontext(303)]
        HRESULT Max([out, retval] double *pVal);
        [propput, id(9), helpstring("Eigenschaft Max"), helpcontext(304)]
        HRESULT Max([in] double dNewVal);
        [id(12), helpstring("Methode Send"), helpcontext(307)]
        HRESULT Send();
        [id(13), helpstring("Methode GetEntry"), helpcontext(308)]
        HRESULT GetEntry([in] long idx, [out] long* pVal, [out] BSTR* pEntryText);
        [propget, id(15), helpstring("Eigenschaft Receivers"), helpcontext(309)]
        HRESULT Receivers([out, retval] IReceiverCol**);
        [propget, id(19), helpstring("Eigenschaft Extension"), helpcontext(312)]
        HRESULT Extension([in] BSTR sID, [out, retval] IDispatch**);
        [propget, id(21), helpstring(""), helpcontext(313)]
        HRESULT Default([out, retval] double *pVal);
        [propput, id(21), helpstring(""), helpcontext(314)]
        HRESULT Default([in] double dNewVal);
        [propget, id(23), helpstring(""), helpcontext(316)]
        HRESULT SigType([out, retval] enum SigType* pVal);
        [propput, id(23), helpstring(""), helpcontext(317)]
        HRESULT SigType([in] enum SigType enNewVal);
        [propget, id(24), helpstring(""), helpcontext(318)]
        HRESULT SigValType([out, retval] enum SigValType* pVal);
        [propput, id(24), helpstring(""), helpcontext(319)]
        HRESULT SigValType([in] enum SigValType enNewVal);  
        [propget, id(27), helpstring("Eigenschaft IsMultiplexerSignal"), helpcontext(320)]
        HRESULT IsMultiplexerSignal([out, retval] VARIANT_BOOL* pVal);
        [propget, id(4000), helpcontext(321)]  HRESULT TransmissionEvent([out, retval] ITransmissionEvent** pEvent);
        [id(4001), helpstring("Methode FilterPreTransmit"), helpcontext(322)]
        HRESULT FilterPreTransmit([in] BSTR sFilter, [in] BSTR sId, [in] enum CallbackPosition enPosition);
        [id(4002), helpstring("Methode FilterPreCopy"), helpcontext(323)]
        HRESULT FilterPreCopy([in] BSTR sFilter, [in] BSTR sId, [in] enum CallbackPosition enPosition);
        [id(4003), helpstring("Methode FilterTxConfirm"), hidden, helpcontext(324)]
        HRESULT FilterTxConfirm([in] BSTR sFilter, [in] BSTR sId, [in] enum CallbackPosition enPosition, VARIANT_BOOL boAsynch);
        [id(4004), helpstring("Methode FilterRxConfirm"), hidden, helpcontext(325)] 
        HRESULT FilterRxConfirm([in] BSTR sFilter, [in] BSTR sId, [in] enum CallbackPosition enPosition, VARIANT_BOOL boAsynch);
 
        [propget, id(4005), helpstring("Eigenschaft PreTransmitEvents"), helpcontext(326)] 
        HRESULT PreTransmitEvents([out, retval] VARIANT_BOOL* pVal);
        [propput, id(4005), helpstring("Eigenschaft PreTransmitEvents"), helpcontext(327)] 
        HRESULT PreTransmitEvents([in] VARIANT_BOOL boVal);
 
        [propget, id(4006), helpstring("Eigenschaft PreCopyEvents"), helpcontext(328)] 
        HRESULT PreCopyEvents([out, retval] VARIANT_BOOL* pVal);
        [propput, id(4006), helpstring("Eigenschaft PreCopyEvents"), helpcontext(329)] 
        HRESULT PreCopyEvents([in] VARIANT_BOOL boVal);
 
        [propget, id(4007), helpstring("Eigenschaft TxConfirmEvents"), hidden, helpcontext(330)]
        HRESULT TxConfirmEvents([out, retval] VARIANT_BOOL* pVal);
        [propput, id(4007), helpstring("Eigenschaft TxConfirmEvents"), hidden, helpcontext(331)] 
        HRESULT TxConfirmEvents([in] VARIANT_BOOL boVal);
 
        [propget, id(4008), helpstring("Eigenschaft RxConfirmEvents"), hidden, helpcontext(332)] 
        HRESULT RxConfirmEvents([out, retval] VARIANT_BOOL* pVal);
        [propput, id(4008), helpstring("Eigenschaft RxConfirmEvents"), hidden, helpcontext(333)] 
        HRESULT RxConfirmEvents([in] VARIANT_BOOL boVal);
    };
 
    [
        uuid(9FAF0811-90CA-4F39-85E0-4316DA3909F4),
        helpstring("Signal Class"),
        helpcontext(823)
    ]
    coclass Signal
    {
        [default] interface ISignal;
        [default, source] dispinterface _ISignalEvents;
    };
 
    [
        object,
        uuid(798E9FD4-5DF5-465C-87E3-B50BA821BB0F),
        dual,
        helpstring("ISignalCol-Schnittstelle"),
        pointer_default(unique),
        hidden,
        helpcontext(334)
    ]
    interface ISignalCol : ICol
    {
        [propget, id(DISPID_VALUE), helpstring("Eigenschaft Item"), helpcontext(335)]
        HRESULT Item([in] VARIANT vIndex, [out, retval] ISignal** pVal);
        [propput, id(7), helpstring("Eigenschaft Factor"), helpcontext(336)]
        HRESULT Factor([in] double dNewVal);
        [propput, id(8), helpstring("Eigenschaft Offset"), helpcontext(337)]
        HRESULT Offset([in] double dNewVal);
        [propput, id(9), helpstring("Eigenschaft Max"), helpcontext(338)]
        HRESULT Max([in] double dNewVal);
        [propput, id(10), helpstring("Eigenschaft Min"), helpcontext(339)]
        HRESULT Min([in] double dNewVal);
        [id(11), helpstring("Methode AddSignal"), helpcontext(340)]
        HRESULT AddSignal([in] BSTR sSigName, [in] long lStartBit, [in] long lBitCount, [in] enum ByteOrder enByteOrder, [out,retval] ISignal**);
        [id(14), helpstring("Methode Delete"), helpcontext(341)]
        HRESULT Delete();
        [propput, id(16), helpstring(""), helpcontext(342)]
        HRESULT SigType([in] enum SigType enNewVal);
        [propput, id(17), helpstring(""), helpcontext(343)]
        HRESULT SigValType([in] enum SigValType enNewVal);
        [propput, id(18), helpstring(""), helpcontext(344)]
        HRESULT Unit([in] BSTR sNewVal);        
        [propput, id(19), helpstring("Eigenschaft ValueTable"), helpcontext(345)]
        HRESULT ValueTable([in] IValueTable* pNewVal);
        [id(20), helpstring("Methode Send"), helpcontext(346)]
        HRESULT Send();
        [id(100), helpcontext(347)] HRESULT AddItem(IDatabaseItem* ppData);
    };
 
    [
        uuid(F5608461-92C9-41B2-941E-254474AF6FA4),
        helpstring("SignalCol Class"),
        helpcontext(822)
    ]
    coclass SignalCol
    {
        [default] interface ISignalCol;
    };
 
    [
        object,
        uuid(6BD5564A-90F9-4A97-9324-CECDE551C19A),
        dual,
        helpstring("ISignalGroup-Schnittstelle"),
        pointer_default(unique),
        hidden,
        helpcontext(0)
    ]
    interface ISignalGroup : IDataEntryBase
    {
        [id(12), helpstring("Methode Apply"), helpcontext(0)]
        HRESULT Apply();
        [propget, id(13), helpstring("Eigenschaft Signals"), helpcontext(383)]
        HRESULT Signals([out, retval] ISignalCol** ppVal);
    };
 
    [
        uuid(96E7C74F-C00F-48C8-9687-5745D5AB2C0D),
        helpstring("SignalGroup Class"),
        helpcontext(0)
    ]
    coclass SignalGroup
    {
        [default] interface ISignalGroup;
        [default, source] dispinterface _IDataEntryBaseEvents;
    };
 
    [
        object,
        uuid(AA36B79D-011D-4F97-81C9-0C43718FB2B6),
        dual,
        helpstring("ISignalGroupCol-Schnittstelle"),
        pointer_default(unique),
        hidden,
        helpcontext(0)
    ]
    interface ISignalGroupCol : ICol
    {
        [propget, id(DISPID_VALUE), helpstring("Eigenschaft Item"), helpcontext(335)]
        HRESULT Item([in] VARIANT vIndex, [out, retval] ISignalGroup**);
        [id(11), helpstring("Methode AddSignalGroup"), helpcontext(340)]
        HRESULT AddSignalGroup([in] BSTR sName, [out, retval] ISignalGroup**);
        [id(14), helpstring("Methode Delete"), helpcontext(341)]
        HRESULT Delete();
        [id(100), helpcontext(347)] HRESULT AddItem([in] IDatabaseItem* ppData);
    };
 
    [
        uuid(9699A0A5-F543-46BB-A9F7-6829A7747735),
        helpstring("SignalGroupCol Class"),
        helpcontext(0)
    ]
    coclass SignalGroupCol
    {
        [default] interface ISignalGroupCol;    
    };
 
    [
        uuid(F5DA7027-3531-46A6-A83F-45BC1C29C3BC),
        helpstring("_ICanMsgEreignisschnittstelle"),
        helpcontext(348)
    ]
    dispinterface _IMessageEvents
    {
    properties:
    methods:
        [id(4), helpstring("Methode OnChanged - Wird vom COM-Thread aufgerufen."), helpcontext(349)]
        HRESULT OnChanged();
        [id(10), helpstring("Methode OnPreTransmit - Wird vom COM-Thread aufgerufen."), helpcontext(350)]
        HRESULT OnPreTransmit([in] TransmissionData* pTransmission, [in] BoolValue* pAllowSend);
        [id(11), helpstring("Methode OnPreCopy - Wird vom COM-Thread aufgerufen."), helpcontext(351)]
        HRESULT OnPreCopy([in] TransmissionData* pTransmission, [out] BoolValue* pAllowCopy);
        [id(12), helpstring("Methode OnTxConfirm - Wird vom COM-Thread aufgerufen."), hidden, helpcontext(352)]
        HRESULT OnTxConfirm([in] TransmissionData* pTransmission);
        [id(13), helpstring("Methode OnRxConfirm - Wird vom COM-Thread aufgerufen."), hidden, helpcontext(353)]
        HRESULT OnRxConfirm([in] TransmissionData* pTransmission);
        [id(14), helpcontext(354)]  HRESULT OnTransmission([in] TransmissionData* pTransmission);
        [id(30), helpstring("Methode OnChangedSync - Wird vom Auslöser-Thread aufgerufen."), restricted, hidden, helpcontext(355)]
        HRESULT OnChangedSync();
        [id(31), helpstring("Methode OnPreTransmitSync - Wird vom Auslöser-Thread aufgerufen."), restricted, hidden, helpcontext(356)]
        HRESULT OnPreTransmitSync([in] TransmissionData* pTransmission, [in] BoolValue* pAllowSend);
        [id(32), helpstring("Methode OnPreCopySync - Wird vom Auslöser-Thread aufgerufen."), restricted, hidden, helpcontext(357)]
        HRESULT OnPreCopySync([in] TransmissionData* pTransmission, [out] BoolValue* pAllowCopy);
        [id(33), helpstring("Methode OnTxConfirmSync - Wird vom Auslöser-Thread aufgerufen."), restricted, hidden, helpcontext(358)]
        HRESULT OnTxConfirmSync([in] TransmissionData* pTransmission);
        [id(34), helpstring("Methode OnRxConfirmSync - Wird vom Auslöser-Thread aufgerufen."), restricted, hidden, helpcontext(359)]
        HRESULT OnRxConfirmSync([in] TransmissionData* pTransmission);
        [id(35), restricted, hidden, helpcontext(360)]  HRESULT OnTransmissionMT([in] TransmissionData* data);
    };
 
    interface ICanEasyApplication;
    interface IMessage;
 
    [
        object,
        uuid(9BFF5BF3-0649-4ff1-B78C-96D85CE51891),
        dual,
        helpstring("IMsgData-Schnittstelle"),
        pointer_default(unique),
        hidden,
        helpcontext(371)
    ]
    interface IMsgData : IDispatch
    {
        [propget, id(0), helpstring("Eigenschaft Array"), helpcontext(372)]
        HRESULT Array([out, retval] VARIANT *pData);
        [propput, id(0), helpstring("Eigenschaft Array"), helpcontext(373)]
        HRESULT Array([in] VARIANT vData);           
        [propget, id(1), helpstring("Eigenschaft Byte"), helpcontext(374)]
        HRESULT Byte([in] long lIndex, [out, retval] byte* pVal);
        [propput, id(1), helpstring("Eigenschaft Byte"), helpcontext(375)]
        HRESULT Byte([in] long lIndex, [in] byte bVal);
    };
 
    [
        uuid(169BDAD4-5B8B-4811-A624-3E7CD29AB988),
        helpstring("MsgData Class"),
        helpcontext(376)
    ]
    coclass MsgData
    {
        [default] interface IMsgData;
    };
 
   // Die Collaction schon mal bekannt machen. Notwendig, weil IMessage IMessageCol sich gegenseitig kenn müssen.
   interface IMessageCol;
 
    [
        object,
        uuid(6B884B54-A58B-4624-A58B-00D97144B46D),
        dual,
        helpstring("IMessage-Schnittstelle"),
        pointer_default(unique),
        hidden,
        helpcontext(377)
    ]
    interface IMessage : IDatabaseItem
    {
        [propget, id(6), helpstring("Eigenschaft MsgID"), helpcontext(378)]
        HRESULT MsgID([out, retval] ICanMessageId** ppVal);
        [propget, id(10), helpstring("Eigenschaft DataChangeEvents"), helpcontext(379)]
        HRESULT DataChangeEvents([out, retval] VARIANT_BOOL *pVal);
        [propput, id(10), helpstring("Eigenschaft DataChangeEvents"), helpcontext(380)]
        HRESULT DataChangeEvents([in] VARIANT_BOOL boNewVal);
        [propget, id(11), helpstring("Eigenschaft Data"), helpcontext(381)]
        HRESULT Data([out, retval] IMsgData** ppData);
        [id(12), helpstring("Methode Send"), helpcontext(382)]
        HRESULT Send();
        [propget, id(13), helpstring("Eigenschaft Signals"), helpcontext(383)]
        HRESULT Signals([out, retval] ISignalCol** ppVal);       
        [propput, id(14), helpstring("Eigenschaft TxEnabled"), helpcontext(384)]
        HRESULT TxEnabled([in] VARIANT_BOOL boNewVal);
        [propget, id(15), helpstring("Eigenschaft Extension"), helpcontext(385)]
        HRESULT Extension([in] BSTR sID, [out, retval] IDispatch** ppVal);
        [propget, id(18), helpstring("Eigenschaft IsMultiplexMessage"), helpcontext(386)]
        HRESULT IsMultiplexMessage([out, retval] VARIANT_BOOL* pVal);
        [propget, id(19), helpstring("Eigenschaft Messages"), helpcontext(387)]
        HRESULT Messages([out, retval] IMessageCol** ppItem);
        [propget, id(20), helpstring("Eigenschaft MuxSignal"), helpcontext(388)]
        HRESULT MuxSignal([out, retval] ISignal** ppItem);
        [propput, id(20), helpstring("Eigenschaft MuxSignal"), helpcontext(389)]
        HRESULT MuxSignal([in] ISignal* pSig);
        [propget, id(21), helpstring("Eigenschaft ActiveOnLin"), helpcontext(390)]
        HRESULT ActiveOnLin([out, retval] VARIANT_BOOL *pVal);
        [propput, id(21), helpstring("Eigenschaft ActiveOnLin"), helpcontext(391)]
        HRESULT ActiveOnLin([in] VARIANT_BOOL boNewVal);        
        [propget, id(22), helpstring("Eigenschaft DLC"), helpcontext(392)]
        HRESULT DLC([out, retval] long* pDlc);        
        [propput, id(22), helpstring("Eigenschaft DLC"), helpcontext(393)]
        HRESULT DLC([in] long lDlc);
        [propget, id(23), helpstring("Eigenschaft AsynchronDataChangeEvent"), helpcontext(394)]
        HRESULT DataChangeEventAsynchron([out, retval] VARIANT_BOOL* pVal);
        [propput, id(23), helpstring("Eigenschaft AsynchronDataChangeEvent"), helpcontext(395)]
        HRESULT DataChangeEventAsynchron([in] VARIANT_BOOL boVal);
        [propget, id(24), helpstring("Eigenschaft Bus"), helpcontext(396)]
        HRESULT Bus([out, retval] IBus** ppBus);
        [propput, id(24), helpstring("Eigenschaft Bus"), helpcontext(397)]
        HRESULT Bus([in] IBus* pBus);
        [id(25), helpstring("Methode Assign"), helpcontext(398)]
        HRESULT Assign([in] IMessage* pMsg);
        [id(26), helpstring("Methode AssignTransmissionData"), helpcontext(399)]
        HRESULT AssignTransmissionData([in] ITransmissionData* pTransmission);
        [propget, id(27), helpstring("Eigenschaft UseTempData"), helpcontext(400)]
        HRESULT UseTempData([out, retval] VARIANT_BOOL* pVal);
        [propput, id(27), helpstring("Eigenschaft UseTempData"), helpcontext(401)]
        HRESULT UseTempData([in] VARIANT_BOOL val);   
 
        [propget, id(29), helpstring("Eigenschaft TrsCtrl1"), helpcontext(402)]
        HRESULT TrsCtrl1([out, retval] ITrsCtrl1MessageExtension** pItem);
        [id(30), helpstring("Methode SetTrsCtrl"), helpcontext(403)]
        HRESULT SetTrsCtrl([in] BSTR sText);
        [propget, id(4000), helpcontext(404)]  HRESULT TransmissionEvent([out, retval] ITransmissionEvent** ppItem);
        [id(4001), helpstring("Methode FilterPreTransmit"), helpcontext(405)] 
        HRESULT FilterPreTransmit([in] BSTR sFilter, [in] BSTR sId, [in] enum CallbackPosition enPosition);
        [id(4002), helpstring("Methode FilterPreCopy"), helpcontext(406)] 
        HRESULT FilterPreCopy([in] BSTR sFilter, [in] BSTR sId, [in] enum CallbackPosition enPosition);
        [id(4003), helpstring("Methode FilterTxConfirm"), hidden, helpcontext(407)] 
        HRESULT FilterTxConfirm([in] BSTR sFilter, [in] BSTR sId, [in] enum CallbackPosition enPosition, VARIANT_BOOL boAsynch);
        [id(4004), helpstring("Methode FilterRxConfirm"), hidden, helpcontext(408)]
        HRESULT FilterRxConfirm([in] BSTR sFilter, [in] BSTR sId, [in] enum CallbackPosition enPosition, VARIANT_BOOL boAsynch);
 
        [propget, id(4005), helpstring("Eigenschaft PreTransmitEvents"), helpcontext(409)]
        HRESULT PreTransmitEvents([out, retval] VARIANT_BOOL* pVal);
        [propput, id(4005), helpstring("Eigenschaft PreTransmitEvents"), helpcontext(410)] 
        HRESULT PreTransmitEvents([in] VARIANT_BOOL boVal);
 
        [propget, id(4006), helpstring("Eigenschaft PreCopyEvents"), helpcontext(411)]
        HRESULT PreCopyEvents([out, retval] VARIANT_BOOL* pVal);
        [propput, id(4006), helpstring("Eigenschaft PreCopyEvents"), helpcontext(412)] 
        HRESULT PreCopyEvents([in] VARIANT_BOOL boVal);
 
        [propget, id(4007), helpstring("Eigenschaft TxConfirmEvents"), hidden, helpcontext(413)]
        HRESULT TxConfirmEvents([out, retval] VARIANT_BOOL* pVal);
        [propput, id(4007), helpstring("Eigenschaft TxConfirmEvents"), hidden, helpcontext(414)] 
        HRESULT TxConfirmEvents([in] VARIANT_BOOL boVal);
 
        [propget, id(4008), helpstring("Eigenschaft RxConfirmEvents"), hidden, helpcontext(415)]
        HRESULT RxConfirmEvents([out, retval] VARIANT_BOOL* pVal);
        [propput, id(4008), helpstring("Eigenschaft RxConfirmEvents"), hidden, helpcontext(416)] 
        HRESULT RxConfirmEvents([in] VARIANT_BOOL boVal);
 
        // Its down here to keep the interface compatible with older interops. Only add new methodas at the end.
        [propget, id(31), helpstring("Eigenschaft SignalGroups"), helpcontext(0)]
        HRESULT SignalGroups([out, retval] ISignalGroupCol** ppVal);
 
        [id(32), helpcontext(0)]
        HRESULT IsTransmitted([in] long timeoutMS, [in] enum DirectionFilter enFilter, [out, retval] VARIANT_BOOL*);
    };
 
    [
        uuid(7B2D4672-7F03-4185-AC3A-9B6E0D1BCEDA),
        helpstring("Message Class"),
        helpcontext(821)
    ]
    coclass Message
    {
        [default] interface IMessage;
        [default, source] dispinterface _IMessageEvents;
    };
 
    [
        object,
        uuid(9A6C3F07-FA13-439B-AD2A-7413E0162B13),
        dual,
        helpstring("IMessageCol-Schnittstelle"),
        pointer_default(unique),
        hidden,
        helpcontext(417)
    ]
    interface IMessageCol : ICol
    {
        [propget, id(DISPID_VALUE), helpstring("Eigenschaft Item"), helpcontext(418)]
        HRESULT Item([in] VARIANT vIndex, [out, retval] IMessage** ppVal);
        [id(7), helpstring("Methode Send"), helpcontext(419)]
        HRESULT Send();
        [id(9), helpstring("Methode AddMessage"), helpcontext(420)]
        HRESULT AddMessage([in] BSTR bstrMsgName, [in] long lMsgId, [in] long lDlc, [out, retval] IMessage**);
        [propput, id(14), helpstring("Eigenschaft TxEnabled"), helpcontext(421)]
        HRESULT TxEnabled([in] VARIANT_BOOL newVal);
        [id(16), helpstring("Methode Delete"), helpcontext(422)]
        HRESULT Delete();
        [id(100), helpcontext(423)] HRESULT AddItem(IDatabaseItem* pData);
    };
 
    [
        uuid(65823CA3-C561-4E2F-BDBE-1F7080B5A9C0),
        helpstring("MessageCol Class"),
        helpcontext(820)
    ]
    coclass MessageCol
    {
        [default] interface IMessageCol;
    };
 
    [
        uuid(D3D7A4ED-FEC1-4AD6-AFC6-9E7FF4DA08F1),
        helpstring("_ICanEcuEreignisschnittstelle"),
        helpcontext(424)
    ]
    dispinterface _IControlUnitEvents
    {
    properties:
    methods:
        [id(10), helpstring("Methode OnPreTransmit - Wird vom COM-Thread aufgerufen."), helpcontext(425)]
        HRESULT OnPreTransmit([in] TransmissionData* pTransmission, [in] BoolValue* boAllowSend);
        [id(11), helpstring("Methode OnPreCopy - Wird vom COM-Thread aufgerufen."), helpcontext(426)]
        HRESULT OnPreCopy([in] TransmissionData* pTransmission, [out] BoolValue* pAllowCopy);
        [id(12), helpstring("Methode OnTxConfirm - Wird vom COM-Thread aufgerufen."), hidden, helpcontext(427)]
        HRESULT OnTxConfirm([in] TransmissionData* pTransmission);
        [id(13), helpstring("Methode OnRxConfirm - Wird vom COM-Thread aufgerufen."), hidden, helpcontext(428)]
        HRESULT OnRxConfirm([in] TransmissionData* pTransmission);
        [id(14), helpcontext(429)]  HRESULT OnTransmission([in] TransmissionData* pTransmission);
        [id(31), helpstring("Methode OnPreTransmitSync - Wird vom Auslöser-Thread aufgerufen."), restricted, hidden, helpcontext(430)]
        HRESULT OnPreTransmitSync([in] TransmissionData* pTransmission, [in] BoolValue* boAllowSend);
        [id(32), helpstring("Methode OnPreCopySync - Wird vom Auslöser-Thread aufgerufen."), restricted, hidden, helpcontext(431)]
        HRESULT OnPreCopySync([in] TransmissionData* pTransmission, [out] BoolValue* boAllowCopy);
        [id(33), helpstring("Methode OnTxConfirmSync - Wird vom Auslöser-Thread aufgerufen."), restricted, hidden, helpcontext(432)]
        HRESULT OnTxConfirmSync([in] TransmissionData* pTransmission);
        [id(34), helpstring("Methode OnRxConfirmSync - Wird vom Auslöser-Thread aufgerufen."), restricted, hidden, helpcontext(433)]
        HRESULT OnRxConfirmSync([in] TransmissionData* pTransmission);
        [id(35), restricted, hidden, helpcontext(434)]  HRESULT OnTransmissionMT([in] TransmissionData* pTransmission);
    };
 
    interface IStackCol;
 
    [
        object,
        uuid(E6F1A520-4DAB-4A71-8D1A-DCAFB8F9E5EB),
        dual,
        helpstring("IControlUnit-Schnittstelle"),
        pointer_default(unique),
        hidden,
        helpcontext(435)
    ]
    interface IControlUnit : IDatabaseItem
    {
        [propput, id(6), helpstring("Eigenschaft TxEnabled"), helpcontext(436)]
        HRESULT TxEnabled([in] VARIANT_BOOL boNewVal);
        [propget, id(7), helpstring("Eigenschaft Simulated"), helpcontext(437)]
        HRESULT Simulated([out, retval] VARIANT_BOOL *pVal);
        [propput, id(7), helpstring("Eigenschaft Simulated"), helpcontext(438)]
        HRESULT Simulated([in] VARIANT_BOOL boNewVal);
        [propget, id(8), helpstring("Eigenschaft Messages"), helpcontext(439)]
        HRESULT Messages([out, retval] IMessageCol* *pVal);
        [propget, id(9), helpstring("Eigenschaft Extension"), helpcontext(440)]
        HRESULT Extension([in] BSTR sID, [out, retval] IDispatch* *pVal);
        [propget, id(12), helpstring("Eigenschaft MsgMode"), helpcontext(441)]
        HRESULT MsgMode([out, retval] enum GenMsgMode *pVal);
        [propput, id(12), helpstring("Eigenschaft MsgMode"), helpcontext(442)]
        HRESULT MsgMode([in] enum GenMsgMode enNewVal);
        [id(13), helpstring("Exports the ecu into a ncf file"), helpcontext(443)]
        HRESULT Export([in] BSTR sFilename);
        [propget, id(15), helpstring("Eigenschaft NMHigh"), helpcontext(444)]
        HRESULT NMHigh([out, retval] INMHighEcuExt** ppItem);
        [propget, id(16), helpstring("Eigenschaft OsekNM"), helpcontext(445)]
        HRESULT OsekNM([out, retval] INMEcuExt** ppItem);
        [id(17), helpstring("Methode SetTrsCtrlForMessages"), helpcontext(446)]
        HRESULT SetTrsCtrlForMessages([in] BSTR sText);
        [propget, id(18), helpstring("Eigenschaft Variables"), hidden, helpcontext(447)]
        HRESULT Variables([out, retval] INamespace **pItem);
        [propget, id(19), helpstring("Eigenschaft Stacks"), helpcontext(439)]
        HRESULT Stacks([out, retval] IStackCol* *pVal);
        [propget, id(4000), helpcontext(448)]  HRESULT TransmissionEvent([out, retval] ITransmissionEvent** pItem);
        [id(4001), helpstring("Methode FilterPreTransmit"), helpcontext(449)] 
        HRESULT FilterPreTransmit([in] BSTR sFilter, [in] BSTR sId, [in] enum CallbackPosition enPosition);
        [id(4002), helpstring("Methode FilterPreCopy"), helpcontext(450)] 
        HRESULT FilterPreCopy([in] BSTR sFilter, [in] BSTR sId, [in] enum CallbackPosition enPosition);
        [id(4003), helpstring("Methode FilterTxConfirm"), hidden, helpcontext(451)] 
        HRESULT FilterTxConfirm([in] BSTR sFilter, [in] BSTR sId, [in] enum CallbackPosition enPosition, VARIANT_BOOL boAsynch);
        [id(4004), helpstring("Methode FilterRxConfirm"), hidden, helpcontext(452)]
        HRESULT FilterRxConfirm([in] BSTR sFilter, [in] BSTR sId, [in] enum CallbackPosition enPosition, VARIANT_BOOL boAsynch);
 
        [propget, id(4005), helpstring("Eigenschaft PreTransmitEvents"), helpcontext(453)]
        HRESULT PreTransmitEvents([out, retval] VARIANT_BOOL* pVal);
        [propput, id(4005), helpstring("Eigenschaft PreTransmitEvents"), helpcontext(454)] 
        HRESULT PreTransmitEvents([in] VARIANT_BOOL boVal);
 
        [propget, id(4006), helpstring("Eigenschaft PreCopyEvents"), helpcontext(455)]
        HRESULT PreCopyEvents([out, retval] VARIANT_BOOL* pVal);
        [propput, id(4006), helpstring("Eigenschaft PreCopyEvents"), helpcontext(456)] 
        HRESULT PreCopyEvents([in] VARIANT_BOOL boVal);
 
        [propget, id(4007), helpstring("Eigenschaft TxConfirmEvents"), hidden, helpcontext(457)]
        HRESULT TxConfirmEvents([out, retval] VARIANT_BOOL* pVal);
        [propput, id(4007), helpstring("Eigenschaft TxConfirmEvents"), hidden, helpcontext(458)] 
        HRESULT TxConfirmEvents([in] VARIANT_BOOL boVal);
 
        [propget, id(4008), helpstring("Eigenschaft RxConfirmEvents"), hidden, helpcontext(459)]
        HRESULT RxConfirmEvents([out, retval] VARIANT_BOOL* pVal);
        [propput, id(4008), helpstring("Eigenschaft RxConfirmEvents"), hidden, helpcontext(460)] 
        HRESULT RxConfirmEvents([in] VARIANT_BOOL boVal);
    };
 
    [
        uuid(69E53238-A06B-420A-8C6B-0DE2685B2E05),
        helpstring("ControlUnit Class"),
        helpcontext(819)
    ]
    coclass ControlUnit
    {
        [default] interface IControlUnit;
        [default, source] dispinterface _IControlUnitEvents;
    };
 
    [
        object,
        uuid(0AB380D1-F3A2-4304-AFF1-9419F5F151A8),
        dual,
        helpstring("IControlUnitCol-Schnittstelle"),
        pointer_default(unique),
        hidden,
        helpcontext(461)
    ]
    interface IControlUnitCol : ICol
    {
        [propget, id(DISPID_VALUE), helpstring("Eigenschaft Item"), helpcontext(462)]
        HRESULT Item([in] VARIANT vIndex, [out, retval] IControlUnit* *pVal);
        [propput, id(7), helpstring("Eigenschaft TxEnabled"), helpcontext(463)]
        HRESULT TxEnabled([in] VARIANT_BOOL boNewVal);
        [propput, id(8), helpstring("Eigenschaft Simulated"), helpcontext(464)]
        HRESULT Simulated([in] VARIANT_BOOL boNewVal);
        [id(9), helpstring("Methode AddControlUnit"), helpcontext(465)]
        HRESULT AddControlUnit([in] BSTR sECUName, [out,retval] IControlUnit**);
        [id(10), helpstring("Methode Delete"), helpcontext(466)]
        HRESULT Delete();
        [id(100), helpcontext(467)] HRESULT AddItem(IDatabaseItem* pData);
    };
 
    [
        uuid(2D55270C-DBE8-40A7-9654-EAE5A70046D5),
        helpstring("ControlUnitCol Class"),
        helpcontext(468)
    ]
    coclass ControlUnitCol
    {
        [default] interface IControlUnitCol;
    };
 
   //
   //       ReceiverCol
   //
 
    [
        object,
        uuid(4B10621F-0779-4aa4-A612-A09811D1A9FA),
        dual,
        helpstring("IReceiverCol-Schnittstelle"),
        pointer_default(unique),
        hidden,
        helpcontext(469)
    ]
    interface IReceiverCol : ICol
    {
        [propget, id(DISPID_VALUE), helpstring("Eigenschaft Item"), helpcontext(470)]
        HRESULT Item([in] VARIANT vIndex, [out, retval] IControlUnit* *pVal);
        [id(7), helpstring("Methode AddControlUnit"), helpcontext(471)]
        HRESULT AddControlUnit([in] IControlUnit* pEcu);
        [id(8), helpstring("Methode RemoveControlUnit"), helpcontext(472)]
        HRESULT RemoveControlUnit([in] IControlUnit* pEcu);      
    };   
 
    [
        uuid(CE3F384A-E2D9-4923-85C8-3753E04D291B),
        helpstring("ReceiverCol Class"),
        helpcontext(473)
    ]
    coclass ReceiverCol
    {
        [default] interface IReceiverCol;
    };
 
 
    coclass Bus;
 
    [
        uuid(526EFE4F-7B0C-4689-83CF-86C0CBE7A0CB),
        helpstring("_IBusEreignisschnittstelle"),
        helpcontext(474)
    ]
    dispinterface _IBusEvents
    {
    properties:
    methods:
        [id(1), helpstring("Methode OnCanEvent - Wird vom COM-Thread aufgerufen."), helpcontext(475)]
        HRESULT OnCanEvent([in] enum CanBusEvent enCanBusEvent);
        [id(2), helpstring("Methode OnCanError - Wird vom COM-Thread aufgerufen."), helpcontext(476)]
        HRESULT OnCanError();
        [id(3), helpstring("Methode OnLinEvent - Wird vom COM-Thread aufgerufen."), helpcontext(477)]
        HRESULT OnLinEvent([in] enum LinBusState enLinBusState);
        [id(4), helpstring("Methode OnLinError - Wird vom COM-Thread aufgerufen."), helpcontext(478)]
        HRESULT OnLinError([in] enum LinBusError enLinBusError, [in] TransmissionData* pTransmission);
        [id(10), helpstring("Methode OnPreTransmit - Wird vom COM-Thread aufgerufen."), helpcontext(479)]
        HRESULT OnPreTransmit([in] TransmissionData* pTransmission, [in] BoolValue* boAllowSend);
        [id(11), helpstring("Methode OnPreCopy - Wird vom COM-Thread aufgerufen."), helpcontext(480)]
        HRESULT OnPreCopy([in] TransmissionData* pTransmission, [out] BoolValue* boAllowCopy);
        [id(12), helpstring("Methode OnTxConfirm - Wird vom COM-Thread aufgerufen."), hidden, helpcontext(481)]
        HRESULT OnTxConfirm([in] TransmissionData* pTransmission);
        [id(13), helpstring("Methode OnRxConfirm - Wird vom COM-Thread aufgerufen."), hidden, helpcontext(482)]
        HRESULT OnRxConfirm([in] TransmissionData* pTransmission);
        [id(14), helpcontext(483)]  HRESULT OnTransmission([in] TransmissionData* pTransmission);
        [id(31), helpstring("Methode OnPreTransmitSync - Wird vom Auslöser-Thread aufgerufen."), restricted, hidden, helpcontext(484)]
        HRESULT OnPreTransmitSync([in] TransmissionData* pTransmission, [in] BoolValue* boAllowSend);
        [id(32), helpstring("Methode OnPreCopySync - Wird vom Auslöser-Thread aufgerufen."), restricted, hidden, helpcontext(485)]
        HRESULT OnPreCopySync([in] TransmissionData* pTransmission, [out] BoolValue* boAllowCopy);
        [id(33), helpstring("Methode OnTxConfirmSync - Wird vom Auslöser-Thread aufgerufen."), restricted, hidden, helpcontext(486)]
        HRESULT OnTxConfirmSync([in] TransmissionData* pTransmission);
        [id(34), helpstring("Methode OnRxConfirmSync - Wird vom Auslöser-Thread aufgerufen."), restricted, hidden, helpcontext(487)]
        HRESULT OnRxConfirmSync([in] TransmissionData* pTransmission);
        [id(35), restricted, hidden, helpcontext(488)]  HRESULT OnTransmissionMT([in] TransmissionData* pTransmission);
        [id(40), helpstring("Methode OnCanEventSync - Wird vom Auslöser-Thread aufgerufen."), restricted, hidden, helpcontext(489)]
        HRESULT OnCanEventSync([in] enum CanBusEvent enCanBusEvent);
        [id(41), helpstring("Methode OnCanErrorSync - Wird vom Auslöser-Thread aufgerufen."), restricted, hidden, helpcontext(490)]
        HRESULT OnCanErrorSync();
        [id(42), helpstring("Methode OnLinEventSync - Wird vom Auslöser-Thread aufgerufen."), restricted, hidden, helpcontext(491)]
        HRESULT OnLinEventSync([in] enum LinBusState enLinBusState);
        [id(43), helpstring("Methode OnLinErrorSync - Wird vom Auslöser-Thread aufgerufen."), restricted, hidden, helpcontext(492)]
        HRESULT OnLinErrorSync([in] enum LinBusError enLinBusError, [in] TransmissionData* pTransmission);
        [id(44), helpcontext(0)]
        HRESULT OnInitError([in] Bus* pBus, [out] BoolValue* boHandled);
    };
 
    interface IVirtualChannel;
 
    [
        object,
        uuid(30C61188-E031-466B-817E-8B1CC2666673),
        dual,
        helpstring("IBus-Schnittstelle"),
        pointer_default(unique),
        hidden,
        helpcontext(493)
    ]
    interface IBus : IDatabaseItem
    {
        [propget, id(6), helpstring("Eigenschaft Baudrate"), helpcontext(494)]
        HRESULT Baudrate([out, retval] long *pVal);
        [propput, id(6), helpstring("Eigenschaft Baudrate"), helpcontext(495)]
        HRESULT Baudrate([in] long lVal);
        [propget, id(7), helpstring("Eigenschaft BTR0"), helpcontext(496)]
        HRESULT BTR0([out, retval] short *pVal);
        [propput, id(7), helpstring("Eigenschaft BTR0"), helpcontext(497), hidden]
        HRESULT BTR0([in] short iNewVal);
        [propget, id(8), helpstring("Eigenschaft BTR1"), helpcontext(498)]
        HRESULT BTR1([out, retval] short *pVal);
        [propput, id(8), helpstring("Eigenschaft BTR1"), helpcontext(499), hidden]
        HRESULT BTR1([in] short iNewVal);
        [propget, id(9), helpstring("Eigenschaft TxEnabled"), helpcontext(500)]
        HRESULT TxEnabled([out, retval] VARIANT_BOOL *pVal);
        [propput, id(9), helpstring("Eigenschaft TxEnabled"), helpcontext(501)]
        HRESULT TxEnabled([in] VARIANT_BOOL boNewVal);
        [propget, id(10), helpstring("Eigenschaft RxEnabled"), helpcontext(502)]
        HRESULT RxEnabled([out, retval] VARIANT_BOOL *pVal);
        [propput, id(10), helpstring("Eigenschaft RxEnabled"), helpcontext(503)]
        HRESULT RxEnabled([in] VARIANT_BOOL boNewVal);
        [id(11), helpstring("Methode SendFreeMsg"), hidden, helpcontext(504)]
        HRESULT SendFreeMsg([in] long nMsgID, [in] VARIANT vData, [in] short nDLC);
        [id(12), helpstring("Methode GetMsgByID"), helpcontext(505)]
        HRESULT GetMsgByID([in] long nMsgID, [out, retval] IMessage** iMsg);
        [id(13), helpstring("Methode GetMsgByName"), helpcontext(506)]
        HRESULT GetMsgByName([in] BSTR sName, [out, retval] IMessage** iMsg);
        [propget, id(14), helpstring("Eigenschaft ControlUnits"), helpcontext(507)]
        HRESULT ControlUnits([out, retval] IControlUnitCol* *pVal);
        [id(15), helpstring("Methode SelectHardware"), helpcontext(508)]
        HRESULT SelectHardware([in] BSTR sHardwareName, [in] VARIANT vHwId, [in] byte bHwChannel);
        [propget, id(16), helpstring("Eigenschaft Extension"), helpcontext(509)]
        HRESULT Extension([in] BSTR sID, [out, retval] IDispatch* *pVal);
        [propget, id(18), helpstring("Eigenschaft LinMaster"), helpcontext(510)]
        HRESULT LinMaster([out, retval] IControlUnit** iEcu);
        [propput, id(18), helpstring("Eigenschaft LinMaster"), helpcontext(511)]
        HRESULT LinMaster([in] IControlUnit* iEcu);
        [propget, id(19), helpstring("Eigenschaft Type"), helpcontext(512)]
        HRESULT Type([out, retval] enum BusType* pType);        
        [id(20), helpstring("Exports the bus into a dbc or ldf file"), helpcontext(513)]
        HRESULT Export([in] BSTR sFilename);
        [propget, id(21), helpstring("Eigenschaft BusStateEvents"), helpcontext(514)]
        HRESULT BusStateEvents([out, retval] VARIANT_BOOL *pVal);
        [propput, id(21), helpstring("Eigenschaft BusStateEvents"), helpcontext(515)]
        HRESULT BusStateEvents([in] VARIANT_BOOL boVal);
        [propget, id(22), helpstring("Eigenschaft BusErrorEvents"), helpcontext(516)]
        HRESULT BusErrorEvents([out, retval] VARIANT_BOOL *val);
        [propput, id(22), helpstring("Eigenschaft BusErrorEvents"), helpcontext(517)]
        HRESULT BusErrorEvents([in] VARIANT_BOOL boVal);
        [id(23), helpstring("Methode GenerateControlUnit"), helpcontext(518)]
        HRESULT GenerateControlUnit ([in] BSTR sFile);
        [id(24), helpstring("Methode SendFreeCanMsg"), hidden, helpcontext(519)]
        HRESULT SendFreeCanMsg([in] long nMsgID, [in] VARIANT vData, [in] short nDLC);
        [id(25), helpstring("Methode SendFreeLinMsg"), hidden, helpcontext(520)]
        HRESULT SendFreeLinMsg([in] long nMsgID, [in] VARIANT vData, [in] short nDLC, [in] enum LinChecksumVersion enChecksumVersion);
        [propget, id(26), helpstring("Eigenschaft Channel"), helpcontext(521)]
        HRESULT Channel([out, retval] byte* pChannel);
        [propput, id(26), helpstring("Eigenschaft Channel"), helpcontext(522)]
        HRESULT Channel([in] byte bChannel);
        [id(27), helpstring("Methode ResetChannel"), helpcontext(523)]
        HRESULT ResetChannel();
        [id(29), helpstring("Methode SetTrsCtrlForMessages"), helpcontext(524)]
        HRESULT SetTrsCtrlForMessages([in] BSTR sText);
        [propget, id(30), helpstring("Property NMHigh"), helpcontext(525)]
        HRESULT NMHigh([out, retval] INMHighBusExt** ppItem);
        [propget, id(31), helpstring("Property OsekNM"), helpcontext(526)]
        HRESULT OsekNM([out, retval] INMBusExt** ppItem);
        [propget, id(32), helpstring("Property VirtualChannel"), helpcontext(527)]
        HRESULT VirtualChannel([out, retval] IVirtualChannel** ppItem);
        [propget, id(33), helpstring("Eigenschaft Variables"), hidden, helpcontext(528)]
        HRESULT Variables([out, retval] INamespace **pItem);
        [propget, id(34), helpcontext(0)] HRESULT InitErrorEvents([out, retval] VARIANT_BOOL* pActive);
        [propput, id(34), helpcontext(0)] HRESULT InitErrorEvents([in] VARIANT_BOOL boActive);
 
        [id(35), helpstring("Methode TransmitMsg"), helpcontext(0)]
        HRESULT TransmitMsg([in] long nMsgID, [in] VARIANT vData, [in] short nDLC, [in] enum TransmissionFlags enFlags);
        [propget, id(4000), helpcontext(529)]  HRESULT TransmissionEvent([out, retval] ITransmissionEvent** ppTransmission);
        [id(4001), helpstring("Methode FilterPreTransmit"), helpcontext(530)] 
        HRESULT FilterPreTransmit([in] BSTR sFilter, [in] BSTR sId, [in] enum CallbackPosition enPosition);
        [id(4002), helpstring("Methode FilterPreCopy"), helpcontext(531)] 
        HRESULT FilterPreCopy([in] BSTR sFilter, [in] BSTR sId, [in] enum CallbackPosition enPosition);
        [id(4003), helpstring("Methode FilterTxConfirm"), hidden, helpcontext(532)]
        HRESULT FilterTxConfirm([in] BSTR sFilter, [in] BSTR sId, [in] enum CallbackPosition enPosition, VARIANT_BOOL boAsynch);
        [id(4004), helpstring("Methode FilterRxConfirm"), hidden, helpcontext(533)]
        HRESULT FilterRxConfirm([in] BSTR sFilter, [in] BSTR sId, [in] enum CallbackPosition enPosition, VARIANT_BOOL boAsynch);
        [propget, id(4005), helpstring("Eigenschaft PreTransmitEvents"), helpcontext(534)]
        HRESULT PreTransmitEvents([out, retval] VARIANT_BOOL* pVal);
        [propput, id(4005), helpstring("Eigenschaft PreTransmitEvents"), helpcontext(535)] 
        HRESULT PreTransmitEvents([in] VARIANT_BOOL boVal);
 
        [propget, id(4006), helpstring("Eigenschaft PreCopyEvents"), helpcontext(536)]
        HRESULT PreCopyEvents([out, retval] VARIANT_BOOL* pVal);
        [propput, id(4006), helpstring("Eigenschaft PreCopyEvents"), helpcontext(537)] 
        HRESULT PreCopyEvents([in] VARIANT_BOOL boVal);
 
        [propget, id(4007), helpstring("Eigenschaft TxConfirmEvents"), hidden, helpcontext(538)]
        HRESULT TxConfirmEvents([out, retval] VARIANT_BOOL* pVal);
        [propput, id(4007), helpstring("Eigenschaft TxConfirmEvents"), hidden, helpcontext(539)] 
        HRESULT TxConfirmEvents([in] VARIANT_BOOL boVal);
 
        [propget, id(4008), helpstring("Eigenschaft RxConfirmEvents"), hidden, helpcontext(540)]
        HRESULT RxConfirmEvents([out, retval] VARIANT_BOOL* pVal);
        [propput, id(4008), helpstring("Eigenschaft RxConfirmEvents"), hidden, helpcontext(541)] 
        HRESULT RxConfirmEvents([in] VARIANT_BOOL boVal);
    };
 
    [
        uuid(F197B5C9-2F23-4F45-8BEB-8BB9D9A3D572),
        helpstring("CanBus Class"),
        helpcontext(817)
    ]
    coclass Bus
    {
        [default] interface IBus;
        [default, source] dispinterface _IBusEvents;
    };
 
    [
        object,
        uuid(0066B75E-3965-41C9-87E6-923DD80A9A26),
        dual,
        helpstring("IBusCol-Schnittstelle"),
        pointer_default(unique),
        hidden,
        helpcontext(542)
    ]
    interface IBusCol : ICol
    {
        [propget, id(DISPID_VALUE), helpstring("Eigenschaft Item"), helpcontext(543)]
        HRESULT Item([in] VARIANT vIndex, [out, retval] IBus* *pVal);        
        [propget, id(10), helpstring("Eigenschaft TxEnabled"), helpcontext(544)]
        HRESULT TxEnabled([out,retval] VARIANT_BOOL*);
        [propput, id(10), helpstring("Eigenschaft TxEnabled"), helpcontext(545)]
        HRESULT TxEnabled([in] VARIANT_BOOL boNewVal);
        [propget, id(11), helpstring("Eigenschaft RxEnabled"), helpcontext(546)]
        HRESULT RxEnabled([out,retval] VARIANT_BOOL*);
        [propput, id(11), helpstring("Eigenschaft RxEnabled"), helpcontext(547)]
        HRESULT RxEnabled([in] VARIANT_BOOL boNewVal);
        [id(12), helpstring("Methode AddBus"), helpcontext(548)]
        HRESULT AddBus([in] enum BusType enType, [in] BSTR sName, [out,retval] IBus**);
        [id(13), helpstring("Methode Delete"), helpcontext(549)]
        HRESULT Delete();
        [id(14), helpstring("Methode ResetChannel"), helpcontext(550)]
        HRESULT ResetChannel();
        [id(100), helpcontext(551)] HRESULT AddItem(IDatabaseItem* pData);
    };
 
    [
        uuid(04771C82-0823-41D0-BA5F-0048A7357157),
        helpstring("BusCol Class"),
        helpcontext(818)
    ]
    coclass BusCol
    {
        [default] interface IBusCol;
 
        // BTP#2952, BTP#2913: COM interface error information
        interface ISupportErrorInfo;
    };
 
 
    [
        object,
        uuid(06CA22E8-7B66-459A-8D3D-B7E1028CA221),
        dual,
        helpstring("ISelection-Schnittstelle"),
        pointer_default(unique),
        hidden,
        helpcontext(552)
    ]
    interface ISelection : ICol
    {
        [propget, id(DISPID_VALUE), helpstring("Eigenschaft Item"), helpcontext(553)]
        HRESULT Item([in] LONG lIndex, [out, retval] IDatabaseItem* *pVal);
        [id(10), helpstring("Methode GetItemAsCanBus"), helpcontext(554)]
        HRESULT GetItemAsBus([in] LONG lIndex, [out, retval] IBus* *iBus);
        [id(11), helpstring("Methode GetItemAsCanEcu"), helpcontext(555)]
        HRESULT GetItemAsControlUnit([in] LONG lIndex, [out, retval] IControlUnit* *iECU);
        [id(12), helpstring("Methode GetItemAsCanMsg"), helpcontext(556)]
        HRESULT GetItemAsMessage([in] LONG lIndex, [out, retval] IMessage* *iMsg);
        [id(13), helpstring("Methode GetItemAsSignal"), helpcontext(557)]
        HRESULT GetItemAsSignal([in] LONG index, [out, retval] ISignal* *iSig);
        [id(14), helpstring("Methode Intersect"), helpcontext(558)]
        HRESULT Intersect([in] ICol* iInput, [out, retval] ISelection* *iSelection);
        [id(15), helpstring("Methode Union"), helpcontext(559)]
        HRESULT Union([in] ICol* iInput, [out, retval] ISelection* *iSelection);
        [id(16), helpstring("Methode Substract"), helpcontext(560)]
        HRESULT Substract([in] ICol* iInput, [out, retval] ISelection* *iSelection);
        [id(17), helpstring("Methode Remove"), helpcontext(561)]
        HRESULT Remove([in] LONG lIndex);
        [id(18), helpstring("Methode AddItem"), helpcontext(562)]
        HRESULT AddItem([in] IDatabaseItem* pData);
    };
 
    [
        uuid(438D2466-E87A-4E32-BE0C-7030296819C3),
        helpstring("Selection Class"),
        helpcontext(828)
    ]
    coclass Selection
    {
        [default] interface ISelection;
    };
 
    [
        uuid(9D443A2A-3420-4178-896C-3F84CFFCBD0E),
        helpstring("_IDatabaseEreignisschnittstelle"),
        helpcontext(563)
    ]
    dispinterface _IDatabaseEvents
    {
    properties:
    methods:
        [id(1), helpstring("Methode OnDBChanged - Obsolete: New Event OnBeginChange and OnEndChange should be used."), helpcontext(564)]
        HRESULT OnDBChanged();
        [id(10), helpstring("Methode OnPreTransmit - Wird vom COM-Thread aufgerufen."), helpcontext(565)]
        HRESULT OnPreTransmit([in] TransmissionData* pTransmission, [in] BoolValue* pAllowSend);
        [id(11), helpstring("Methode OnPreCopy - Wird vom COM-Thread aufgerufen."), helpcontext(566)]
        HRESULT OnPreCopy([in] TransmissionData* pTransmission, [out] BoolValue* pAllowCopy);
        [id(12), helpstring("Methode OnTxConfirm - Wird vom COM-Thread aufgerufen."), hidden, helpcontext(567)]
        HRESULT OnTxConfirm([in] TransmissionData* pTransmission);
        [id(13), helpstring("Methode OnRxConfirm - Wird vom COM-Thread aufgerufen."), hidden, helpcontext(568)]
        HRESULT OnRxConfirm([in] TransmissionData* pTransmission);
        [id(14), helpcontext(569)]  HRESULT OnTransmission([in] TransmissionData* pTransmission);
        [id(31), helpstring("Methode OnPreTransmitSync - Wird vom Auslöser-Thread aufgerufen."), restricted, hidden, helpcontext(570)]
        HRESULT OnPreTransmitSync([in] TransmissionData* pTransmission, [in] BoolValue* pAllowSend);
        [id(32), helpstring("Methode OnPreCopySync - Wird vom Auslöser-Thread aufgerufen."), restricted, hidden, helpcontext(571)]
        HRESULT OnPreCopySync([in] TransmissionData* pTransmission, [out] BoolValue* pAllowCopy);
        [id(33), helpstring("Methode OnTxConfirmSync - Wird vom Auslöser-Thread aufgerufen."), restricted, hidden, helpcontext(572)]
        HRESULT OnTxConfirmSync([in] TransmissionData* pTransmission);
        [id(34), helpstring("Methode OnRxConfirmSync - Wird vom Auslöser-Thread aufgerufen."), restricted, hidden, helpcontext(573)]
        HRESULT OnRxConfirmSync([in] TransmissionData* pTransmission);
        [id(35), restricted, hidden, helpcontext(574)]  HRESULT OnTransmissionMT([in] TransmissionData* pTransmission);
        [id(40), helpstring("Methode OnBeginChange"), hidden, helpcontext(575)]
        HRESULT OnBeginChange();
        [id(41), helpstring("Methode OnBeginChangeSync"), restricted, hidden, helpcontext(576)]
        HRESULT OnBeginChangeSync();
        [id(42), helpstring("Methode OnEndChange"), hidden, helpcontext(577)]
        HRESULT OnEndChange();
        [id(43), helpstring("Methode OnEndChangeSync"), restricted, hidden, helpcontext(578)]
        HRESULT OnEndChangeSync();
        [id(44), helpstring("Methode OnAttributeChange"), helpcontext(0)]
        HRESULT OnAttributeChange([in] IAttribute* pItem);
        [id(45), helpstring("Methode OnAttributeChangeSync"), restricted, hidden, helpcontext(0)]
        HRESULT OnAttributeChangeSync([in] IAttribute* pItem);
    };
 
    [
        object,
        uuid(EA27720B-F782-4E88-A259-8E0AB8E67379),
        dual,
        helpstring("IDatabase-Schnittstelle"),
        pointer_default(unique),
        hidden,
        helpcontext(579)
    ]
    interface IDatabase : IDatabaseItem
    {
        [id(7), helpstring("Methode Load"), helpcontext(580)]
        HRESULT Load([in] BSTR sFilePath);
        [id(8), helpstring("Methode Save"), helpcontext(581)]
        HRESULT Save([in] BSTR sFilePath);
        [id(9), helpstring("Methode FindObject"), helpcontext(582)]
        HRESULT FindObject([in] IObjectFilter* filter, [in] IDispatch* iStartObj, [out, retval] IDatabaseItem**);
        [propget, id(10), helpstring("Eigenschaft Busses"), helpcontext(583)]
        HRESULT Busses([out, retval] IBusCol* *pVal);        
        [id(12), helpstring("Methode GenerateBus"), helpcontext(584)]
        HRESULT GenerateBus([in] BSTR sBusName, [in] BSTR sFile);
 
        [id(14), helpstring("Methode FindObjects"), helpcontext(585)]
        HRESULT FindObjects([in] IObjectFilter* pFilter, [out, retval] ISelection**);      
        [propget, id(15), helpstring("Eigenschaft ValueTables"), helpcontext(586)]
        HRESULT ValueTables([out, retval] IValueTableCol** ppVal);
        [propget, id(17), helpstring("Eigenschaft DBChangedEvents"), helpcontext(587)]
        HRESULT DBChangedEvents([out, retval] VARIANT_BOOL *pVal);
        [propput, id(17), helpstring("Eigenschaft DBChangedEvents"), helpcontext(588)]
        HRESULT DBChangedEvents([in] VARIANT_BOOL boVal);
 
        // BTP#1459: New COM interface to open the database browse dialog
        [id(18), helpstring("Methode BrowseDatabase"), helpcontext(589)]
        HRESULT BrowseDatabase([in] long hParentWindow, [in] IDatabaseItem *iRootObj, [in] IDatabaseItem *iSelectionObj, [in] enum DatabaseBrowse_Show enKindShow, [in] enum DatabaseBrowse_Select enKindSelect, [in] BSTR sTitle, [out, retval] IDatabaseItem**);
 
        // BTP#5534: It should be possible to notify the begin and end of a huge amount of changes to the database
        [id(19), helpstring("Methode BeginDatabaseChange"),  hidden, helpcontext(590)]
        HRESULT BeginDatabaseChange();
        [id(20), helpstring("Methode EndDatabaseChange"), hidden, helpcontext(591)]
        HRESULT EndDatabaseChange();
        [id(22), helpstring("Methode SetTrsCtrlForMessages"), helpcontext(592)]
        HRESULT SetTrsCtrlForMessages([in] BSTR sText);
        [propget, id(23), helpstring("Eigenschaft Variables"), hidden, helpcontext(593)]
        HRESULT Variables([out, retval] INamespace **pItem);
        [id(24), helpstring("Methode CreateTransmissionEvent"), helpcontext(594)]
        HRESULT CreateTransmissionEvent([out, retval] ITransmissionEvent** pItem);
        [propget, id(25), helpstring("Methode ValueChangeEvents"), helpcontext(0)]
        HRESULT AttributeChangeEvents([out, retval] VARIANT_BOOL* boVal);
        [propput, id(25), helpstring("Methode ValueChangeEvents"), helpcontext(0)]
        HRESULT AttributeChangeEvents([in] VARIANT_BOOL boVal);
        [propget, id(4000), helpcontext(594)]  HRESULT TransmissionEvent([out, retval] ITransmissionEvent** pItem);
        [id(4001), helpstring("Methode FilterPreTransmit"), helpcontext(595)] 
        HRESULT FilterPreTransmit([in] BSTR sFilter, [in] BSTR sId, [in] enum CallbackPosition enPosition);
        [id(4002), helpstring("Methode FilterPreCopy"), helpcontext(596)] 
        HRESULT FilterPreCopy([in] BSTR sFilter, [in] BSTR sId, [in] enum CallbackPosition enPosition);
        [id(4003), helpstring("Methode FilterTxConfirm"), hidden, helpcontext(597)]
        HRESULT FilterTxConfirm([in] BSTR sFilter, [in] BSTR sId, [in] enum CallbackPosition enPosition, VARIANT_BOOL boAsynch);
        [id(4004), helpstring("Methode FilterRxConfirm"), hidden, helpcontext(598)]
        HRESULT FilterRxConfirm([in] BSTR sFilter, [in] BSTR sId, [in] enum CallbackPosition enPosition, VARIANT_BOOL boAsynch);
 
        [propget, id(4005), helpstring("Eigenschaft PreTransmitEvents"), helpcontext(599)]
        HRESULT PreTransmitEvents([out, retval] VARIANT_BOOL* pVal);
        [propput, id(4005), helpstring("Eigenschaft PreTransmitEvents"), helpcontext(600)] 
        HRESULT PreTransmitEvents([in] VARIANT_BOOL boVal);
 
        [propget, id(4006), helpstring("Eigenschaft PreCopyEvents"), helpcontext(601)]
        HRESULT PreCopyEvents([out, retval] VARIANT_BOOL* pVal);
        [propput, id(4006), helpstring("Eigenschaft PreCopyEvents"), helpcontext(602)] 
        HRESULT PreCopyEvents([in] VARIANT_BOOL boVal);
 
        [propget, id(4007), helpstring("Eigenschaft TxConfirmEvents"), hidden, helpcontext(603)]
        HRESULT TxConfirmEvents([out, retval] VARIANT_BOOL* pVal);
        [propput, id(4007), helpstring("Eigenschaft TxConfirmEvents"), hidden, helpcontext(604)] 
        HRESULT TxConfirmEvents([in] VARIANT_BOOL boVal);
 
        [propget, id(4008), helpstring("Eigenschaft RxConfirmEvents"), hidden, helpcontext(605)]
        HRESULT RxConfirmEvents([out, retval] VARIANT_BOOL* pVal);
        [propput, id(4008), helpstring("Eigenschaft RxConfirmEvents"), hidden, helpcontext(606)] 
        HRESULT RxConfirmEvents([in] VARIANT_BOOL boVal);
 
        [id(4010), helpcontext(607)] HRESULT CreateOffsetFactorConversion([out, retval] IOffsetFactorConversion**);
        [id(4011), helpcontext(608)] HRESULT CreateDatabaseItem([in] BSTR sType, [out, retval] IDatabaseItem**);
        [id(4012), helpcontext(0)] HRESULT SetValue([in] BSTR sRef, [in] VARIANT val);
        [id(4013), helpcontext(0)] HRESULT GetValue([in] BSTR sRef, [out, retval] VARIANT*);
        [id(4014), helpcontext(0)] HRESULT GetValueString([in] BSTR sRef, [out, retval] BSTR*);
        [id(4015), helpcontext(0)] HRESULT Execute([in] BSTR sRef);
        [id(4016), helpcontext(0)] HRESULT TransmitRef([in] BSTR sRef);
        [id(4017), helpcontext(0)] HRESULT TransmitRefOn([in] BSTR sRef, [in] enum BusType enBusType, [in] long channel);
        [id(4018), helpcontext(0)] HRESULT IsValueLess([in] BSTR sRef, [in] double dVal, [in] long timeout, [out, retval] VARIANT_BOOL*);
        [id(4019), helpcontext(0)] HRESULT IsValueGreater([in] BSTR sRef, [in] double dVal, [in] long timeout, [out, retval] VARIANT_BOOL*);
        [id(4020), helpcontext(0)] HRESULT IsValueLessOrEqual([in] BSTR sRef, [in] double dVal, [in] long timeout, [out, retval] VARIANT_BOOL*);
        [id(4021), helpcontext(0)] HRESULT IsValueGreaterOrEqual([in] BSTR sRef, [in] double dVal, [in] long timeout, [out, retval] VARIANT_BOOL*);
        [id(4022), helpcontext(0)] HRESULT IsValueEqual([in] BSTR sRef, [in] double dVal, [in] long timeout, [out, retval] VARIANT_BOOL*);
        [id(4023), helpcontext(0)] HRESULT IsValueInRange([in] BSTR sRef, [in] double dMinVal, [in] double dMaxVal, [in] long timeout, [out, retval] VARIANT_BOOL*);
        [id(4024), helpcontext(0)] HRESULT IsTransmitted([in] BSTR sRef, [in] long timeoutMS, [in] enum DirectionFilter enFilter, [out, retval] VARIANT_BOOL*);
        [id(4025), helpcontext(0)] HRESULT ReadData([in] BSTR sRef);
        [id(4026), helpcontext(0)] HRESULT WriteData([in] BSTR sRef);
        [id(4027), helpcontext(0)] HRESULT CopyValue([in] IValue* s, [in] IValue* d);
    };
 
    [
        uuid(3DD669CD-1CFE-424D-B62B-3C5EC3CC120D),
        helpstring("Database Class"),
        helpcontext(816)
    ]        
    coclass Database
    {
        [default] interface IDatabase;
        [default, source] dispinterface _IDatabaseEvents;
    };
 
 
   // Botschafts-Filter
    [
        object,
        uuid(03FAB949-7C74-4E00-9DFB-7EDF0CE5B0D7),
        dual,
        helpstring("IRecordFilter-Schnittstelle"),
        pointer_default(unique),
        hidden,
        helpcontext(609)
    ]
    interface IRecordFilter : IDispatch
    {
        [id(1), helpstring("Methode AndWith"), helpcontext(610)]
        HRESULT AndWith([in] IRecordFilter* iFilter);
        [id(2), helpstring("Methode Invert"), helpcontext(611)]
        HRESULT Invert();
        [id(3), helpstring("Methode OrWith"), helpcontext(612)]
        HRESULT OrWith([in] IRecordFilter* iFilter);
#ifdef _WIN64
        [propget, id(4), restricted, hidden] HRESULT Pointer([out, retval] LONG_PTR* pItem); //VSTAHidden       /* FIXME_64Bit */
#else
        [propget, id(4), restricted, hidden] HRESULT Pointer([out, retval] long* pItem); //VSTAHidden
#endif
 
    };
 
    [
        uuid(024608D4-6C2D-418E-BEC0-F97E15D7D4F2),
        helpstring("RecordFilter Class"),
        helpcontext(613)
    ]
    coclass RecordFilter
    {
        [default] interface IRecordFilter;
    };
 
    [
        object,
        uuid(6AC27A2F-C09E-4E4F-B540-D33F341C0648),
        dual,
        helpstring("IRecordChannel-Schnittstelle"),
        pointer_default(unique),
        hidden,
        helpcontext(0)
    ]
    interface IRecordChannel : IDispatch
    {
        [propget, id(DISPID_VALUE), helpstring("Property Name"), helpcontext(0)]
        HRESULT Name([out, retval] BSTR *sName);
        [propput, id(DISPID_VALUE), helpstring("Property Name"), helpcontext(0)] 
        HRESULT Name([in] BSTR sName);   
        [id(10), helpstring("Methode Write"), helpcontext(0)]
        HRESULT Write([in] IDatabaseItem* pItem, [in] double dTimestamp, [in] byte bSender);
    };
 
    [
        uuid(2837C304-5502-4A75-BE34-CBB2CBC5BBF2),
        helpstring("RecordChannel Class"),
        helpcontext(0)
    ]
    coclass RecordChannel
    {
        [default] interface IRecordChannel;
    };
 
   [
      object,
      uuid(28858700-EF24-4cd9-A015-8F81044F3F3C),
      dual,
      helpstring("IRecordEntry-Schnittstelle"),
      pointer_default(unique),
      hidden,
      helpcontext(614)
   ]
   interface IRecordEntry : IDispatch
   {
        [propget, id(1), helpstring("Eigenschaft Timestamp"), helpcontext(615)]
        HRESULT Timestamp([out, retval] double *pVal);
        [propget, id(2), helpstring("Eigenschaft Type"), helpcontext(616)]
        HRESULT Type([out, retval] enum RecordEntryType* pType);
        [propget, id(3), helpstring("Eigenschaft DatabaseItem"), helpcontext(0)]
        HRESULT DatabaseItem([out, retval] IDatabaseItem** pItem);
    };
 
    [
        object,
        uuid(82BF99F0-9FF3-4411-B15D-862AA1FB9CF1),
        dual,
        helpstring("IMarkerRecordEntry-Schnittstelle"),
        pointer_default(unique),
        hidden,
        helpcontext(617)
    ]
    interface IMarkerRecordEntry : IRecordEntry
    {
        [propget, id(20), helpstring("Eigenschaft Value"), helpcontext(618)]
        HRESULT Value([out, retval] long* pVal);
    };
 
    [
        uuid(1CDE722E-808A-4767-925D-B39754BBFD70),
        helpstring("MarkerRecordEntry Class"),
        helpcontext(619)
    ]
    coclass MarkerRecordEntry
    {
        [default] interface IMarkerRecordEntry;
    };
 
    [
        object,
        uuid(A9116FEB-D104-4dc3-92AA-8D456CF06337),
        dual,
        helpstring("IEnvVarRecordEntry-Schnittstelle"),
        pointer_default(unique),
        hidden,
        helpcontext(620)
    ]
    interface IEnvVarRecordEntry : IRecordEntry
    {
        [propget, id(20), helpstring("Eigenschaft Value"), helpcontext(621)]
        HRESULT Value([out, retval] double *pVal);
        [propget, id(21), helpstring("Eigenschaft EnvVar"), helpcontext(622)]
        HRESULT EnvVar([out, retval] IEnvVar** ppItem);
    };
 
    [
        uuid(DB472512-8C54-49cc-8AC1-8600B8135BA4),
        helpstring("EnvVarRecordEntry Class"),
        helpcontext(623)
    ]
    coclass EnvVarRecordEntry
    {
        [default] interface IEnvVarRecordEntry;
    };
 
    [
        object,
        uuid(62D6D348-A358-407b-B00B-E8DA921BADCA),
        dual,
        helpstring("IBusRecordEntry-Schnittstelle"),
        pointer_default(unique),
        hidden,
        helpcontext(624)
    ]
    interface IBusRecordEntry : IRecordEntry
    {
        [propget, id(20), helpstring("Eigenschaft Bus"), helpcontext(625)]
        HRESULT Bus([out, retval] IBus** ppBus);
        [propget, id(21), helpstring("Eigenschaft Channel"), helpcontext(626)]
        HRESULT Channel([out, retval] byte* pChannel);     
    };
 
    [
        object,
        uuid(DED5458B-B125-4a82-BA17-6F4F1E3824D4),
        dual,
        helpstring("ICanBusStateRecordEntry-Schnittstelle"),
        pointer_default(unique),
        hidden,
        helpcontext(627)
    ]
    interface ICanBusStateRecordEntry : IBusRecordEntry
    {
        [propget, id(25), helpstring("Eigenschaft RxCount"), helpcontext(628)]
        HRESULT RxCount([out, retval] byte* pVal);
        [propget, id(26), helpstring("Eigenschaft TxCount"), helpcontext(629)]
        HRESULT TxCount([out, retval] byte* pVal);
        [propget, id(27), helpstring("Eigenschaft BusState"), helpcontext(630)]
        HRESULT BusState([out, retval] enum CanBusEvent* pVal);
    };
 
    [
        uuid(B0AFAA4A-409B-49f3-A815-7B4F80640F27),
        helpstring("CanBusStateRecordEntry Class"),
        helpcontext(631)
    ]
    coclass CanBusStateRecordEntry
    {
        [default] interface ICanBusStateRecordEntry;
    };
 
    [
        object,
        uuid(38FE927E-8A7D-477b-9783-642285BA8CAF),
        dual,
        helpstring("ILinBusStateRecordEntry-Schnittstelle"),
        pointer_default(unique),
        hidden,
        helpcontext(632)
    ]
    interface ILinBusStateRecordEntry : IBusRecordEntry
    {
        [propget, id(25), helpstring("Eigenschaft BusState"), helpcontext(633)]
        HRESULT BusState([out, retval] enum LinBusEvent* pVal);
    };
 
    [
        uuid(11BC41BB-D335-40b4-8C70-5A9591F43799),
        helpstring("LinBusStateRecordEntry Class"),
        helpcontext(634)
    ]
    coclass LinBusStateRecordEntry
    {
        [default] interface ILinBusStateRecordEntry;
    };
 
    [
        object,
        uuid(658F9CB3-E0CF-40d0-ACD1-2AB33EEC3CD0),
        dual,
        helpstring("ICanBusErrorRecordEntry-Schnittstelle"),
        pointer_default(unique),
        hidden,
        helpcontext(635)
    ]
    interface ICanBusErrorRecordEntry : IBusRecordEntry
    {
    };
 
    [
        uuid(4ED669DD-C12A-48b3-A771-0301B39A7C3E),
        helpstring("CanBusErrorRecordEntry Class"),
        /*helpcontext(636)*/
    ]
    coclass CanBusErrorRecordEntry
    {
        [default] interface ICanBusErrorRecordEntry;
    };
 
    [
        object,
        uuid(E11776C1-0748-499b-BE74-EE80B4C27A04),
        dual,
        helpstring("IMsgRecordEntry-Schnittstelle"),
        pointer_default(unique),
        hidden,
        helpcontext(637)
    ]
    interface IMsgRecordEntry : IBusRecordEntry
    {
        [propget, id(25), helpstring("Eigenschaft MsgType"), helpcontext(638)]
        HRESULT MsgType([out, retval] enum MsgRecordEntryType* pType);
        [propget, id(26), helpstring("Eigenschaft Message"), helpcontext(639)]
        HRESULT Message([out, retval] IMessage** ppMsg);
        [propget, id(27), helpstring("Eigenschaft Id"), helpcontext(640)]
        HRESULT Id([out, retval] IMessageId** ppMsgId);
        [propget, id(28), helpstring("Eigenschaft Dlc"), helpcontext(641)]
        HRESULT Dlc([out, retval] byte* pDlc);
        [propget, id(29), helpstring("Eigenschaft Data"), helpcontext(642)]
        HRESULT Data([out, retval] VARIANT* pData);
        [propget, id(30), helpstring("Eigenschaft Rx"), helpcontext(643)]
        HRESULT Rx([out, retval] VARIANT_BOOL *pVal);
    };
 
    [
        uuid(8C79FF15-2AE2-46e1-AAD1-7CB9A63E6EC1),
        helpstring("MsgRecordEntry Class"),
        helpcontext(644)
    ]
    coclass MsgRecordEntry
    {
        [default] interface IMsgRecordEntry;
    };
 
    [
        object,
        uuid(DDF87EC3-71BB-4c46-85E3-477461FD9FA3),
        dual,
        helpstring("ICanMsgRecordEntry-Schnittstelle"),
        pointer_default(unique),
        hidden,
        helpcontext(645)
    ]
    interface ICanMsgRecordEntry : IMsgRecordEntry
    {
    };
 
    [
        uuid(037406E2-9A42-4eaf-916C-1DA5F321E0C3),
        helpstring("CanMsgRecordEntry Class"),
        helpcontext(646)
    ]
    coclass CanMsgRecordEntry
    {
        [default] interface ICanMsgRecordEntry;
    };
 
    [
        object,
        uuid(613B02EC-F202-48ee-B685-2BBDDD46FDFE),
        dual,
        helpstring("ILinMsgRecordEntry-Schnittstelle"),
        pointer_default(unique),
        hidden,
        helpcontext(647)
    ]
    interface ILinMsgRecordEntry : IMsgRecordEntry
    {
        [propget, id(11), helpstring("Eigenschaft ChecksumVersion"), helpcontext(648)]
        HRESULT ChecksumVersion([out, retval] enum LinChecksumVersion* pType);
    };
 
    [
        uuid(7C96230B-0F20-4a08-A8AC-B0D6D202BCA4),
        helpstring("LinMsgRecordEntry Class"),
        helpcontext(649)
    ]
    coclass LinMsgRecordEntry
    {
        [default] interface ILinMsgRecordEntry;
    };
 
   [
      object,
      uuid(81FEB39A-7D3D-469b-A671-D1FA02ADBF0D),
      dual,
      helpstring("IFlexrayMsgRecordEntry-Schnittstelle"),
      pointer_default(unique),
      hidden,
      helpcontext(650)
   ]
   interface IFlexrayMsgRecordEntry : IMsgRecordEntry
   {
   };
 
    [
        object,
        uuid(F782342E-19E3-4EEB-B4EB-689183C5E874),
        dual,
        helpstring("IRecordIterator-Schnittstelle"),
        pointer_default(unique),
        hidden,
        helpcontext(651)
    ]
    interface IRecordIterator : IDispatch
    {
        [propget, id(1), helpstring("Eigenschaft RecordEntry"), helpcontext(652)]
        HRESULT RecordEntry([out, retval] IRecordEntry** ppRecordEntry); 
        [id(2), helpstring("Methode Next"), helpcontext(653)]
        HRESULT Next([out, retval] VARIANT_BOOL* pValid);
        [id(3), helpstring("Methode Previous"), helpcontext(654)]
        HRESULT Previous([out, retval] VARIANT_BOOL* pValid);
        [id(4), helpstring("Methode First"), helpcontext(655)]
        HRESULT First();
        [id(5), helpstring("Methode Last"), helpcontext(656)]
        HRESULT Last();
        [id(6), helpstring("Methode Compare"), helpcontext(657)]
        HRESULT Compare([in] IRecordIterator* pIterator, [out, retval] VARIANT_BOOL* pEqual);
        [propget, id(7), helpstring("Eigenschaft IsFirst"), helpcontext(658)]
        HRESULT IsFirst([out, retval] VARIANT_BOOL *pVal);
        [propget, id(8), helpstring("Eigenschaft IsLast"), helpcontext(659)]
        HRESULT IsLast([out, retval] VARIANT_BOOL *pVal);
        [id(9), helpstring("Methode gethIterator"), hidden, restricted, helpcontext(660)] //VSTAHidden
#ifdef _WIN64
        HRESULT gethIterator([out, retval] LONG_PTR * hIterator);       /* FIXME_64Bit */
#else
        HRESULT gethIterator([out, retval] long * hIterator);
#endif
 
        [id(10), helpstring("Methode Seek"), helpcontext(661)]
        HRESULT Seek([in] double dTimestamp, [out, retval] VARIANT_BOOL*);
    };
 
    [
        uuid(B9CF5762-ACD7-48B5-9D9C-CC67DD497C55),
        helpstring("RecordIterator Class"),
        helpcontext(662)
    ]
    coclass RecordIterator
    {
        [default] interface IRecordIterator;
    };
 
    [
        object,
        uuid(10B71B2B-5191-4ba6-81AF-8CA62835480D),
        dual,
        helpstring("IRecord-Schnittstelle"),
        pointer_default(unique),
        hidden,
        helpcontext(663)
    ]
    interface IRecord : IDispatch
    {
        [id(1), helpstring("Methode CreateMsgIdFilter"), helpcontext(609), hidden]
        HRESULT CreateMsgIdFilter([in] IBus* iBus, [in] long nMsgID, [out, retval] IRecordFilter**);
        [id(3), helpstring("Methode CreateItemFilter"), helpcontext(611)]
        HRESULT CreateItemFilter([in] IDatabaseItem* pItem, [out, retval] IRecordFilter**);
        [id(4), helpstring("Methode CreateFilter"), helpcontext(612)]
        HRESULT CreateFilter([in] enum RecordEntryType enEntryType, [out, retval] IRecordFilter**);
        [id(5), helpstring("Methode CreateIterator"), helpcontext(613)]
        HRESULT CreateIterator([in] IRecordFilter* pFilter, [out, retval] IRecordIterator**);
        [propget, id(6), helpstring("Eigenschaft RecordChangeEvents - Definiert ob das RecordChangeEvent gesendet werden soll."), helpcontext(614)]
        HRESULT RecordChangeEvents([out, retval] VARIANT_BOOL *pVal);
        [propput, id(6), helpstring("Eigenschaft RecordChangeEvents - Definiert ob das RecordChangeEvent gesendet werden soll."), helpcontext(615)]
        HRESULT RecordChangeEvents([in] VARIANT_BOOL boNewVal);
        [id(7), helpstring("Methode Load"), helpcontext(616)]
        HRESULT Load([in] BSTR sFile);
        [id(8), helpstring("Methode Unload"), helpcontext(617)]
        HRESULT Unload();
        [id(9), helpstring("Methode Save"), helpcontext(0)]
        HRESULT Save(BSTR sFile);
        [propget, id(10), helpstring("Methode Autostart"), helpcontext(0)]
        HRESULT Autostart([out, retval] VARIANT_BOOL* boActive);
        [propput, id(10), helpstring("Methode Autostart"), helpcontext(0)]
        HRESULT Autostart([in] VARIANT_BOOL boActive);
        [id(11), helpstring("Methode Start"), helpcontext(0)]
        HRESULT Start();
        [id(12), helpstring("Methode Stop"), helpcontext(0)]
        HRESULT Stop();
        [id(13), helpstring("Methode CreateMarker"), helpcontext(0)]
        HRESULT CreateMarker();
        [id(14), helpstring("Methode CreateStringTypeFilter"), helpcontext(0)]
        HRESULT CreateStringTypeFilter([in] BSTR sType, [out, retval] IRecordFilter**);
        [id(15), helpstring("Methode CreateRecordChannel"), helpcontext(0)]
        HRESULT CreateRecordChannel([out, retval] IRecordChannel**);
        [id(16), helpstring("Methode WriteTrace"), helpcontext(0)]
        HRESULT WriteTrace([in] double timestamp, [in] long identifier, [in] VARIANT byteArray, [in] long length, [out, retval] VARIANT_BOOL*);
        [id(17), helpstring("Methode Restart"), helpcontext(0)]
        HRESULT Restart();
        [id(18), helpstring("Method ShowMethodInExplorer"), helpcontext(0)]
        HRESULT ShowMethodInExplorer();
        [id(19), helpstring("Method AnalyzeRecord"), helpcontext(0)]
        HRESULT AnalyzeRecord(BSTR sourceFile, BSTR destinationFile, int outputType, int delta);
        [propget, id(20), helpstring("Eigenschaft WriteEvents - Definiert ob das WriteEvents gesendet werden soll."), helpcontext(614)]
        HRESULT WriteEvents([out, retval] VARIANT_BOOL *pVal);
        [propput, id(20), helpstring("Eigenschaft WriteEvents - Definiert ob das WriteEvents gesendet werden soll."), helpcontext(615)]
        HRESULT WriteEvents([in] VARIANT_BOOL boNewVal);
        [id(21), helpstring("Methode SaveFiltered - Speichert vom Iterator mit dem Iterator-Filter."), helpcontext(0)]
        HRESULT SaveFiltered(BSTR sFile, [in]IRecordIterator* pIterator);
        [id(22), helpstring("Methode SavePart - Speichert vom aktuellen Ende die angegebenen Sekunden rückwärts. Gespeichert wird in das angegebene Verzeichnis oder das aktuelle ArberitsbereichVerzeichnis. Wennd er Dateiname nicht angegeben wird, wird der aktuelle zeitstempel verwendet."), helpcontext(0)]
        HRESULT SavePart([in]VARIANT_BOOL async, [in]BSTR sDirectory, [in]int seconds, [in]BSTR sFileName);
        [id(23), helpcontext(0)]
        HRESULT SaveRange([in]VARIANT_BOOL async, [in]BSTR sDirectory, [in]BSTR sFileName, [in]double fromTS, [in]double toTS);
    };
 
    [
        uuid(A5D18D9A-BD73-4edd-9C3A-8F2FC8BB800D),
        helpstring("_IRecordEventsEreignisschnittstelle"),
        helpcontext(678)
    ]
    dispinterface _IRecordEvents
    {
    properties:
    methods:
        [id(1), helpstring("Methode OnRecordChanged - Wird vom COM-Thread aufgerufen."), helpcontext(679)]
        HRESULT OnRecordChanged([in] enum RecordChangedEvent nReason);
        [id(30), helpstring("Methode OnRecordChangedSync - Wird vom Auslöser-Thread aufgerufen."), restricted, hidden, helpcontext(680)]
        HRESULT OnRecordChangedSync([in] enum RecordChangedEvent nReason);
        [id(2), helpstring("Methode OnWrite - Wird vom COM-Thread aufgerufen."), helpcontext(0)]
        HRESULT OnWrite();
        [id(31), helpstring("Methode OnWriteSync - Wird vom Auslöser-Thread aufgerufen."), restricted, hidden, helpcontext(0)]
        HRESULT OnWriteSync();
    };
 
    [
        uuid(99C3E284-5E69-4c8f-B5DD-53C9486542CA),
        helpstring("Record Class"),
        helpcontext(681)
    ]
    coclass Record
    {
        [default] interface IRecord;
        [default, source] dispinterface _IRecordEvents;
    };
 
   // BTP#5828: Tree access through COM interface: Menu
   interface ICanEasyMenuControl;
 
   // BTP#5828: Tree access through COM interface: Menu
    [
        object,
        uuid(A2FAF55D-B4A9-4D46-8949-27493AF03E13),
        dual,
        helpstring("IMenu-Schnittstelle"),
        pointer_default(unique),
        hidden
    ]
    interface IMenu : IDispatch
    {
        [propget, id(DISPID_VALUE), helpstring("Eigenschaft Item"), helpcontext(682)]
        HRESULT Item([in] VARIANT vIndex, [out, retval] ICanEasyMenuControl **pVal);
        [id(10), helpstring("Methode AddItem"), helpcontext(683)]
        HRESULT AddItem([in] ICanEasyMenuControl *pItem);
        [propget, id(20), helpstring("Eigenschaft MenuId"), helpcontext(684)]
        HRESULT MenuId([out, retval] __int64 *pId);
        [id(30), helpstring("Methode DeleteMenu"), helpcontext(685)]
        HRESULT DeleteMenu([in] ICanEasyMenuControl *pItem);
        [id(40), helpstring("Methode SetMenuItemId"), helpcontext(686)]
        HRESULT SetMenuItemId([in] long lCurId, [in] long lNewId);
        [id(50), helpstring("Methode SetMenuItemText"), helpcontext(687)]
        HRESULT SetMenuItemText([in] long lId, [in] BSTR sText);
        [id(60), helpstring("Methode SetMenuItemFlags"), helpcontext(688)]
        HRESULT SetMenuItemFlags([in] long lId, [in] long lFlags);
    };
 
    // BTP#5828: Tree access through COM interface: Menu
    [
        uuid(1B579905-DCDD-44FE-8E8B-16AB4996679F),
        helpstring("CanEasyMenu Class"),
    ]
    coclass CanEasyMenu
    {
        [default] interface IMenu;
        //[default, source] dispinterface _IMenuEvents;
    };
 
   // BTP#5828: Tree access through COM interface: Menu
    [
        object,
        uuid(EB1EA31B-0B58-4439-BDE4-68745C4DBB3F),
        dual,
        helpstring("ICanEasyMenuControl-Schnittstelle"),
        pointer_default(unique),
        hidden
    ]
    interface ICanEasyMenuControl : IDispatch
    {
        [propget, id(10), helpstring("Eigenschaft Type")]
        HRESULT Type([out, retval] enum CanEasyMenuControlType *pType);
        [propput, id(10), helpstring("Eigenschaft Type")]
        HRESULT Type([in] enum CanEasyMenuControlType enType);
 
        [propget, id(20), helpstring("Eigenschaft Id")]
        HRESULT Id([out, retval] long *pId);
        [propput, id(20), helpstring("Eigenschaft Id")]
        HRESULT Id([in] long lId);
 
        [propget, id(30), helpstring("Eigenschaft Text")]
        HRESULT Text([out, retval] BSTR *pText);
        [propput, id(30), helpstring("Eigenschaft Text")]
        HRESULT Text([in] BSTR sNewText);
 
        [propget, id(40), helpstring("Eigenschaft Checked")]
        HRESULT Checked([out, retval] VARIANT_BOOL *pFlag);
        [propput, id(40), helpstring("Eigenschaft Checked")]
        HRESULT Checked([in] VARIANT_BOOL boFlag);
 
        [propget, id(50), helpstring("Eigenschaft Grayed")]
        HRESULT Grayed([out, retval] VARIANT_BOOL *pFlag);
        [propput, id(50), helpstring("Eigenschaft Grayed")]
        HRESULT Grayed([in] VARIANT_BOOL boFlag);
 
        // Be careful: every usage of 'Menu' property will create new menu - it is correct behavior,
        // you can find details in implementation of get_Menu method.
        [propput, id(60), helpstring("Eigenschaft Menu")]
        HRESULT Menu([in] IMenu *pMenu);
 
        [propget, id(70), helpstring("Eigenschaft SubMenu")]
        HRESULT SubMenu([out, retval] IMenu **pMenu);
        [propput, id(70), helpstring("Eigenschaft SubMenu")]
        HRESULT SubMenu([in] IMenu *pMenu);
    };
 
   // BTP#5828: Tree access through COM interface: Menu
    [
        uuid(19B6B15A-EEB9-4262-8974-FF11DE0E47ff),
        helpstring("CanEasyMenuControl Class"),
    ]
    coclass CanEasyMenuControl
    {
        [default] interface ICanEasyMenuControl;
        //[default, source] dispinterface _ICanEasyItemComEvents;
    };
 
    // BTP#5828: Tree access through COM interface
    interface ICanEasyItemComCol;
 
    // BTP#5828: Tree access through COM interface
 
    [
        object,
        uuid(CE0FF6D0-425D-11E1-B86C-0800200C9A66),
        dual,
        helpstring("ICanEasyItemCom-Schnittstelle"),
        pointer_default(unique),
        hidden
    ]
    interface ICanEasyItemCom : IDispatch //Not ITransmissionItem or IDatabaseItem, because item can have no corresponded database object
    {
        //TODO: Some methods are not implemented yet - they are commented
 
        [propget, id(10), helpstring("Eigenschaft StringType")]
        HRESULT StringType([out, retval] BSTR *pText);
        [propget, id(20), helpstring("Eigenschaft StringRef")]
        HRESULT StringRef([out, retval] BSTR *pText);
        [propget, id(30), helpstring("Eigenschaft Image")]
        HRESULT Image([out, retval] long *pIndex);
        [propput, id(30), helpstring("Eigenschaft Image")]
        HRESULT Image([in] long nIndex);
        //enum ImageState { NormalImage, WarningImage, ErrorImage };
        //[id(12), helpstring("Methode GetImageState")] HRESULT ImageState GetImageState();
 
        [propget, id(40), helpstring("Eigenschaft Text")]
        HRESULT Text([out, retval] BSTR *pText);
        [propput, id(40), helpstring("Eigenschaft Text")]
        HRESULT Text([in] BSTR sNewText);
        [propget, id(60), helpstring("Eigenschaft Children")]
        HRESULT Children([out, retval] ICanEasyItemComCol**); 
        [id(70), helpstring("Eigenschaft IsAddChildAllowed")]
        HRESULT IsAddChildAllowed([in] ICanEasyItemCom *pItem, [in, defaultvalue(1)] VARIANT_BOOL boRecursive, [out, retval] VARIANT_BOOL*);
        [id(100), helpstring("Methode Delete")]
        HRESULT Delete();
        [id(300), helpstring("Methode SetImageByName")]
        HRESULT SetImageByName([in] BSTR sImageName);
        [propget, id(310), helpstring("Eigenschaft Menu")]
        HRESULT Menu([out, retval] IMenu **pMenu);
    };
 
    // BTP#5828: Tree access through COM interface
    [
        uuid(05C29AA2-2789-4BCD-A42C-CA5E7667C2C0),
        helpstring("_IDatabaseEreignisschnittstelle")
    ]
    dispinterface _ICanEasyItemComEvents
    {
    properties:
    methods:
        //[id(10), helpstring("Methode OnPreIsAddChildAllowed")] HRESULT bool OnPreIsAddChildAllowed(ICanEasyItem& item, ICanEasyItem& parent, ICanEasyItem* pBefore, bool recursive);
        //[id(11), helpstring("Methode OnPreAddChild")] HRESULT ICanEasyItem* OnPreAddChild(ICanEasyItem& item, ICanEasyItem& parent, const ICanEasyItem* pBefore);
        //[id(12), helpstring("Methode OnPreAddChildren")] HRESULT ICanEasyItem* OnPreAddChildren(ICanEasyItem& item, ICanEasyItem& parent, ICanEasyItem* pBefore, bool recursive);
        //[id(13), helpstring("Methode OnPreGetMenu")] HRESULT ICanEasyItem* OnPreGetMenu(CMenu& menu, ICanEasyItem* pItem = NULL);
        //[id(14), helpstring("Methode OnPreMenuCommand")] HRESULT ICanEasyItem* OnPreMenuCommand(int command, ICanEasyItem* pItem = NULL);
        //[id(15), helpstring("Methode OnPreDoubleClick")] HRESULT ICanEasyItem* OnPreDoubleClick(ICanEasyItem* pItem = NULL);
        //[id(16), helpstring("Methode OnPreSelection")] HRESULT ICanEasyItem* OnPreSelection(ICanEasyItem* pItem = NULL);
        //[id(17), helpstring("Methode OnPreUnSelection")] HRESULT ICanEasyItem* OnPreUnSelection(ICanEasyItem* pItem = NULL);
        //[id(18), helpstring("Methode OnPreKeyDown")] HRESULT ICanEasyItem* OnPreKeyDown(DWORD key, ICanEasyItem* pItem = NULL);
 
        //[id(20), helpstring("Methode OnGetMenu")]
        //HRESULT OnGetMenu(CMenu& menu);
 
        //[id(21), helpstring("Methode OnMenuCommand")] HRESULT bool OnMenuCommand(int command);
        //[id(22), helpstring("Methode OnDoubleClick")] HRESULT void OnDoubleClick();
        //[id(23), helpstring("Methode OnSelection")] HRESULT void OnSelection();
        //[id(24), helpstring("Methode OnUnSelection")] HRESULT void OnUnSelection();
        //[id(25), helpstring("Methode OnKeyDown")] HRESULT void OnKeyDown(DWORD key);
        //[id(26), helpstring("Methode OnExpanded")] HRESULT void OnExpanded();
        //[id(27), helpstring("Methode OnCollapsed")] HRESULT void OnCollapsed();
        [id(20), helpstring("Methode IsSetTextAllowed - Wird vom COM-Thread aufgerufen.")]
        HRESULT IsSetTextAllowed([in] IBoolValue *pAllow);
        [id(30), helpstring("Methode OnTextChanged - Wird vom COM-Thread aufgerufen.")]
        HRESULT OnTextChanged();
        [id(40), helpstring("Methode OnFillMenu - Wird vom COM-Thread aufgerufen.")]
        HRESULT OnFillMenu([in] IMenu *pMenu);
        [id(50), helpstring("Methode OnMenuCommand - Wird vom COM-Thread aufgerufen.")]
        HRESULT OnMenuCommand(long lCommand);
        [id(60), helpstring("Methode OnExtendChildMenu - Wird vom COM-Thread aufgerufen.")]
        HRESULT OnExtendChildMenu([in] IMenu *pMenu, [in] ICanEasyItemCom *pItem);
        [id(70), helpstring("Methode OnPreChildMenuCommand - Wird vom COM-Thread aufgerufen.")]
        HRESULT OnPreChildMenuCommand(long lCommand, [in] ICanEasyItemCom *pItem);
        [id(80), helpstring("Methode OnKeyDown - Wird vom COM-Thread aufgerufen.")]
        HRESULT OnKeyDown(long lKey);
        [id(90), helpstring("Methode OnDoubleClick - Wird vom COM-Thread aufgerufen.")]
        HRESULT OnDoubleClick();
        [id(120), helpstring("Methode IsSetTextAllowedSync - Wird vom Auslöser-Thread aufgerufen."), hidden, restricted]
        HRESULT IsSetTextAllowedSync([in] IBoolValue *pAllow);
        [id(130), helpstring("Methode OnTextChangedSync - Wird vom Auslöser-Thread aufgerufen."), hidden, restricted]
        HRESULT OnTextChangedSync();
        [id(140), helpstring("Methode OnFillMenuSync - Wird vom Auslöser-Thread aufgerufen."), hidden, restricted]
        HRESULT OnFillMenuSync([in] IMenu *pMenu);
        [id(150), helpstring("Methode OnMenuCommandSync - Wird vom Auslöser-Thread aufgerufen."), hidden, restricted]
        HRESULT OnMenuCommandSync(long lCommand);
        [id(160), helpstring("Methode OnExtendChildMenuSync - Wird vom Auslöser-Thread aufgerufen."), hidden, restricted]
        HRESULT OnExtendChildMenuSync([in] IMenu *pMenu, [in] ICanEasyItemCom *pItem);
        [id(170), helpstring("Methode OnPreChildMenuCommandSync - Wird vom Auslöser-Thread aufgerufen."), hidden, restricted]
        HRESULT OnPreChildMenuCommandSync(long lCommand, [in] ICanEasyItemCom *pItem);
        [id(180), helpstring("Methode OnKeyDownSync - Wird vom Auslöser-Thread aufgerufen."), hidden, restricted]
        HRESULT OnKeyDownSync(long lCommand);
        [id(190), helpstring("Methode OnDoubleClickSync - Wird vom Auslöser-Thread aufgerufen."), hidden, restricted]
        HRESULT OnDoubleClickSync();
    };
 
    // BTP#5828: Tree access through COM interface
    [
        uuid(DB834CB0-432D-11E1-B86C-0800200C9A66),
        helpstring("CanEasyItemCom Class"),
    ]
    coclass CanEasyItemCom
    {
        [default] interface ICanEasyItemCom;
        [default, source] dispinterface _ICanEasyItemComEvents;
        interface ISupportErrorInfo;
    };
 
    // BTP#5828: Tree access through COM interface
    [
        object,
        uuid(95A5A3C4-5BD6-4DA4-8E4E-C906B3C93896),
        dual,
        helpstring("ICanEasyItemComCol-Schnittstelle"),
        pointer_default(unique)
    ]
    interface ICanEasyItemComCol : IDispatch //IHiddenCol
    {
        [propget, id(DISPID_VALUE), helpstring("Eigenschaft Item"), helpcontext(689)]
        HRESULT Item([in] VARIANT vIndex, [out, retval] ICanEasyItemCom **pVal);
        [id(10), helpstring("Methode AddItem"), helpcontext(690)]
        HRESULT AddItem([in] ICanEasyItemCom *pItem);
        [id(20), helpstring("Methode RemoveItem")]
        HRESULT RemoveItem([in] ICanEasyItemCom *pItem);
    };
 
    // BTP#5828: Tree access through COM interface
    [
        uuid(967408FF-BBF7-4332-B0AA-D794F4B7090B),
        helpstring("CanEasyItemComCol Class"),
    ]
    coclass CanEasyItemComCol
    {
        [default] interface ICanEasyItemComCol;
        interface ISupportErrorInfo;
    };   
 
    // BTP#5828: Tree access through COM interface
 
    [
        object,
        uuid(690E4B47-3D0E-43c7-A531-DC6E3BF83220),
        dual,
        helpstring("ICanEasyTree-Schnittstelle"),
        pointer_default(unique),
        hidden
    ]
    interface ICanEasyTree : IDispatch
    {
        [id(1), helpstring("Methode Item")]
        HRESULT Item([in] BSTR sItemRef, [in] BSTR sItemType, [out, retval] ICanEasyItemCom**);
        [id(2), helpstring("Methode CreateItem")]
        HRESULT CreateItem([out, retval] ICanEasyItemCom**);
        [id(3), helpstring("Methode AddRootItem")]
        HRESULT AddRootItem([in] ICanEasyItemCom *pItem, [in] long lPos);
    };
 
   [
      uuid(EA80DA3D-220C-45e6-A207-C2CC9DF9878D),
      helpstring("CanEasyTree Class"),
   ]
   coclass CanEasyTree
   {
      [default] interface ICanEasyTree;
      interface ISupportErrorInfo;
   };
 
    [
        dual,
        object,
        uuid(DB2BAC8B-1B28-4a20-8C77-36194DFC70B5),
        helpstring("ILicense Schnittstelle"),
        nonextensible,
        pointer_default(unique),
        helpcontext(691)
    ]
    interface ILicense : IDispatch
    {
        [id(1), helpstring("Methode GetFeatureId"), helpcontext(692)]
        HRESULT GetFeatureId([in]BSTR sId, [out, retval] long*);
        [id(2), helpstring("Methode IsFeatureSet"), helpcontext(693)]
        HRESULT IsFeatureSet([in]long lFeatureId, [out, retval] VARIANT_BOOL*);
        [id(3), helpstring("Methode IsApplication"), helpcontext(694)]
        HRESULT IsApplication([in]BSTR sApplicationName, [out, retval] VARIANT_BOOL*);
    };
 
    [
        uuid(1A33CCB1-D8C9-43c6-8CB0-3E60B6771E65),
        helpstring("License Class"),
        helpcontext(695)
    ]
    coclass License
    {
        [default] interface ILicense;
    };
 
   
   // ITimer Interface
    [
        object,
        uuid(EEA9C950-1787-45D7-BB64-FE267384014C),
        dual,
        helpstring("ITimer-Schnittstelle"),
        helpcontext(696),
        pointer_default(unique)
    ]
    interface ITimer : IDispatch
    {
        // Ids dürfen erst bei 4 beginnen, da aufgrund der Abwärtskompabilität von ITimerControl dessen IDs
        // nicht geändert werden dürfen (IDBereich: 1-3)
        [propget, id(4), helpstring("Property StartMode"), helpcontext(697)] 
        HRESULT StartMode([out, retval] enum StartMode* pVal);
        [propput, id(4), helpstring("Property StartMode"), helpcontext(698)] 
        HRESULT StartMode([in] enum StartMode enNewVal);
 
        [propget, id(5), helpstring("Property TimerMode"), helpcontext(699)]
        HRESULT TimerMode([out, retval] enum TimerMode* pVal);
        [propput, id(5), helpstring("Property TimerMode"), helpcontext(700)] 
        HRESULT TimerMode([in] enum TimerMode enNewVal);
 
        [propget, id(6), helpstring("Property TimeMode"), helpcontext(701)]
        HRESULT TimeMode([out, retval] enum TimeMode* pVal);
        [propput, id(6), helpstring("Property TimeMode"), helpcontext(702)] 
        HRESULT TimeMode([in] enum TimeMode enNewVal);
 
        [propget, id(7), helpstring("Property TimerStatus"), helpcontext(703)] 
        HRESULT TimerStatus([out, retval] enum TimerStatus* pVal);
 
        [propget, id(8), helpstring("Property Now"), helpcontext(704)]
        HRESULT Now([out, retval] double* pVal);
 
        [propget, id(9), helpstring("Property TimerEvents"), helpcontext(705)]
        HRESULT TimerEvents([out, retval] VARIANT_BOOL* pVal);
        [propput, id(9), helpstring("Property TimerEvents"), helpcontext(706)] 
        HRESULT TimerEvents([in] VARIANT_BOOL boNewVal);
 
        [id(10), helpstring("Methode Start"), helpcontext(707)] 
        HRESULT Start();
        [id(11), helpstring("Methode Stop"), helpcontext(708)]
        HRESULT Stop();
        [id(12), helpstring("Methode Suspend"), helpcontext(709)]
        HRESULT Suspend();
        [propget, id(30), helpstring("Property Counter"), helpcontext(710)]
        HRESULT Counter([out, retval] double* pVal);
    };
 
    // ITimerControl Interface
    [
        object,
        uuid(46CBEE68-E085-42E6-A479-26CD0EA5C001),
        dual,
        helpstring("ITimerControl-Schnittstelle"),
        pointer_default(unique),
        helpcontext(711)
    ]
    interface ITimerControl : ITimer
    {
        [id(1), helpstring("Methode Set"), helpcontext(712), hidden]
        HRESULT Set([in] long nElapse);
        [id(2), helpstring("Methode Kill"), helpcontext(713), hidden]
        HRESULT Kill();
        [propget, id(3), helpstring("Property Value"), helpcontext(714)]
        HRESULT Value([out, retval] double* pVal);
        [propput, id(3), helpstring("Property Value"), helpcontext(715)] 
        HRESULT Value([in] double dNewVal);
    };
 
    [
        uuid(785F95D5-98A6-4A9E-8144-A1944B1CB21B),
        helpstring("_ITimerControlEreignisschnittstelle"),
        helpcontext(716)
    ]
    dispinterface _ITimerControlEvents
    {
    properties:
    methods:
        [id(1), helpstring("Methode OnTimer - Wird vom COM-Thread aufgerufen."), helpcontext(717)]
        HRESULT OnTimer();
        [id(30), helpstring("Methode OnTimerSync - Wird vom Auslöser-Thread aufgerufen."), hidden, restricted, helpcontext(718)]
        HRESULT OnTimerSync();
    
    };
 
    [
        uuid(2554EDBF-9F0D-4605-9B21-9344A7455B3A),
        helpstring("TimerControl Class"),
        helpcontext(719)
    ]
    coclass TimerControl
    {
        [default] interface ITimerControl;
        [default, source] dispinterface _ITimerControlEvents;
    };
 
   // ICompareTimer Interface
    [
        object,
        uuid(37A8A194-B3FA-4BB0-8DB0-86DA4F555BF3),
        dual,
        helpstring("ICompareTimer-Schnittstelle"),
        pointer_default(unique)
    ]
    interface ICompareTimer : ITimer
    {
        [propget, id(13), helpstring("Property CompareList")]
        HRESULT CompareList([out, retval] VARIANT *pVal);
        [propput, id(13), helpstring("Property CompareList")] 
        HRESULT CompareList([in] VARIANT vNewVal);
        [propget, id(17), helpstring("Property IntervalLap")]
        HRESULT IntervalLap([out, retval] long* pVal);
    };
 
    [
        object,
        uuid(6978001E-2170-4944-A99F-C5F4219E3CCB),
        dual,
        helpstring("ICompareTimerArg-Schnittstelle"),
        pointer_default(unique)
    ]
    interface ICompareTimerArgs : IDispatch
    {
        [propget, id(1), helpstring("Property Timestamp")]
        HRESULT Timestamp([out, retval] double *pTimestamp);
        [propget, id(2), helpstring("Property Index")]
        HRESULT Index([out, retval] long *pVal);
        [propget, id(3), helpstring("Property IntervalLap")]
        HRESULT IntervalLap([out, retval] long *pVal);
        [propget, id(4), helpstring("Property Data")]
        HRESULT Data([out, retval] VARIANT *pVal);
    };
 
    coclass CompareTimer;
    coclass CompareTimerArgs;
 
    [
        uuid(D8E8D2D7-6663-4B4E-B10D-A06725CC5C74),
        helpstring("_ICompareTimerEreignisschnittstelle")
    ]
    dispinterface _ICompareTimerEvents
    {
    properties:
    methods:
        [id(1), helpstring("MethodCreatee OnCompareTimer"), helpcontext(720)]
        HRESULT OnCompareTimer([in] CompareTimerArgs *pArgs);
        [id(2), helpstring("Methode OnCompareTimerMT"), helpcontext(721), restricted, hidden]
        HRESULT OnCompareTimerMT([in] IDispatch* pSender, [in] CompareTimerArgs *pArgs);
    };
 
    [
        uuid(12D6146E-7279-4CBF-B564-3083467E1517),
        helpstring("CompareTimer Class"),
    ]
    coclass CompareTimer
    {
        [default] interface ICompareTimer;
        [default, source] dispinterface _ICompareTimerEvents;
        interface ISupportErrorInfo;
    };
 
    [
        uuid(32587368-DE20-4A2A-A42D-1B052176BE7A),
        helpstring("CompareTimerArgs Class"),
    ]
    coclass CompareTimerArgs
    {
        [default] interface ICompareTimerArgs;
    };
 
    [
        object,
        uuid(214AD1BD-F7DE-4CFD-9F8E-050A1414CB83),
        dual,
        helpstring("ICompareTimerArg-Schnittstelle"),
        pointer_default(unique)
    ]
    interface ICaptureEntry : IDispatch
    {
        [propget, id(2), helpstring("Property Data")]
        HRESULT Data([out, retval] VARIANT *pVal);
        [propget, id(1), helpstring("Property Timestamp")]
        HRESULT Timestamp([out, retval] double *pVal);
    };
 
    [
        uuid(7161AC48-2889-4A06-8107-0E3A86533172),
        helpstring("CaptureEntry Class"),
        helpcontext(738)
    ]
    coclass CaptureEntry
    {
        [default] interface ICaptureEntry;
    };
   
    [
        object,
        uuid(DF1C37FC-8613-4536-98F1-B50A680ECFE4),
        dual,
        helpstring("ICaptureEntryCol-Schnittstelle"),
        pointer_default(unique)
    ]
    interface ICaptureEntryCol : IDispatch
    {
        [propget, id(DISPID_NEWENUM), helpstring("Eigenschaft _NewEnum"), restricted, hidden, helpcontext(722)] //VSTAHidden
        HRESULT _NewEnum([out, retval] IUnknown** pVal);
        [propget, id(DISPID_VALUE), helpstring("Eigenschaft Item"), helpcontext(723)]
        HRESULT Item([in] long lIndex, [out, retval] ICaptureEntry** pVal);
        [propget, id(1), helpstring("Property Count")]
        HRESULT Count([out, retval] long* pVal);
    };
 
    [
        uuid(4BB21A30-3DBA-48CC-91BE-3B18B87EE53F),
        helpstring("CaptureEntryCol Class"),
        helpcontext(739)
    ]
    coclass CaptureEntryCol
    {
        [default] interface ICaptureEntryCol;
    };
 
    [
        object,
        uuid(BAFD3F59-2E99-4C70-924E-AF4D41727A4B),
        dual,
        helpstring("ICaptureTimerArgs-Schnittstelle"),
        pointer_default(unique),
        helpcontext(730)
    ]
    interface ICaptureTimerArgs : IEventArgs
    {
        [propget, id(2), helpstring("Property Index"), helpcontext(731)] 
        HRESULT Index([out, retval] long *pVal);
        [propget, id(3), helpstring("Property CaptureValue"), helpcontext(732)]
        HRESULT CaptureValue([out, retval] ICaptureEntry** pVal);
    };
 
    [
        uuid(8F5CE5FB-7226-41EF-858B-1587A2A02066),
        helpstring("CaptureTimerArgs Class"),
        helpcontext(737)
    ]
    coclass CaptureTimerArgs
    {
        [default] interface ICaptureTimerArgs;
    };
   
 
    // ICaptureTimer Interface
    [
        object,
        uuid(874D0CE9-89BB-4F55-A7A2-274BAAB2CFF1),
        dual,
        helpstring("ICaptureTimer-Schnittstelle"),
        pointer_default(unique),
        helpcontext(724)
    ]
    interface ICaptureTimer : ITimer
    {
        // ICaptureTimer Interface
        [propget, id(14), helpstring("Property CaptureList"), helpcontext(725)] 
        HRESULT CaptureList([out, retval] ICaptureEntryCol** pVal);
        [id(15), helpstring("Methode Capture"), helpcontext(726)]
        HRESULT Capture([in] VARIANT vData);
        [propget, id(16), helpstring("Property MemoryBlockSize"), helpcontext(727)]
        HRESULT MemoryBlockSize([out, retval] long* pSize);
        [propput, id(16), helpstring("Property MemoryBlockSize"), helpcontext(728)]
        HRESULT MemoryBlockSize([in] long lSize);
        [propget, id(17), helpstring("Property Data"), helpcontext(729)]
        HRESULT Data([out, retval] VARIANT* pData);
    };
 
    [
        uuid(1CCC2F08-8AC1-41D2-8653-C65EF45DE423),
        helpstring("_ICaptureTimerEreignisschnittstelle"),
        helpcontext(733)
    ]
    dispinterface _ICaptureTimerEvents
    {
    properties:
    methods:
        [id(1), helpstring("MethodCreatee OnCaptureTimer"), helpcontext(734)] 
        HRESULT OnCaptureTimer([in] CaptureTimerArgs *pArgs);
        [id(2), helpstring("Methode OnCaptureTimerMT"), helpcontext(735), restricted, hidden]
        HRESULT OnCaptureTimerMT([in] IDispatch* pSender, [in] CaptureTimerArgs *pArgs);
    };
 
    [
        uuid(C734D4F7-7AC4-4D47-804E-80AD3727331B),
        helpstring("CaptureTimer Class"),
        helpcontext(736)
    ]
    coclass CaptureTimer
    {
        [default] interface ICaptureTimer;
        [default, source] dispinterface _ICaptureTimerEvents;
    };
 
    [
        object,
        uuid(47643FEC-116C-4EE2-8887-708620CAE5B5),
        dual,
        pointer_default(unique),
        helpcontext(740)
    ]
    interface ISerialPort : IDispatch
    {
        [id(1), helpcontext(741)] HRESULT Write([in] VARIANT vData, [in] long lTimeout, [out, retval] long*);
        [id(2), helpcontext(742)] HRESULT Read([in] long lLength, [in] long lTimeout, [out, retval] VARIANT*);
        [id(3), helpcontext(743)] HRESULT Open([out, retval] VARIANT_BOOL*);
        [id(4), helpcontext(744)] HRESULT Close();
        [propget, id(5), helpcontext(745)] HRESULT Baudrate([out, retval] long* pBaudrate);
        [propput, id(5), helpcontext(746)] HRESULT Baudrate([in] long lBaudrate);
        [propget, id(6), helpcontext(747)] HRESULT DataBits([out, retval] long* pDataBits);
        [propput, id(6), helpcontext(748)] HRESULT DataBits([in] long lDataBits);
        [propget, id(7), helpcontext(749)] HRESULT StopBits([out, retval] long* pStopBits);
        [propput, id(7), helpcontext(750)] HRESULT StopBits([in] long oStopBits);
        [propget, id(8), helpcontext(751)] HRESULT Parity([out, retval] long* pParity);
        [propput, id(8), helpcontext(752)] HRESULT Parity([in] long lParity);
        [propget, id(9), helpcontext(753)] HRESULT Port([out, retval] long* pPort);
        [propput, id(9), helpcontext(754)] HRESULT Port([in] long lPort);
    };
 
    [
        uuid(4C6643EA-265F-4795-8DDB-17E0DC601D80),
        helpcontext(755)
    ]
    coclass SerialPort
    {
        [default] interface ISerialPort;
    };
 
    interface IWorkspaceModule;
    interface IHardware;
    interface IVirtualChannelCol;
 
    [
        object,
        uuid(A45C7585-8A5F-477F-BC2F-B51A28125C3C),
        dual,
        helpstring("ICAPL-Interface"),
        pointer_default(unique),
        helpcontext(0)
    ]
    interface ICAPL : IDispatch
    {
        [id(1), helpcontext(0)]
        HRESULT Compile([in] VARIANT_BOOL boOverwrite, [out, retval] VARIANT_BOOL*);
        [id(2), helpcontext(0)]
        HRESULT AddCANFile([in] BSTR file);
        [id(3), helpcontext(0)]
        HRESULT RemoveCANFile([in] BSTR file);
        [id(4), helpcontext(0)]
        HRESULT ActivateCANFile([in] BSTR file);
        [id(5), helpcontext(0)]
        HRESULT DeactivateCANFile([in] BSTR file);
        [id(6), helpcontext(0)]
        HRESULT AddDll([in] BSTR file);
        [id(7), helpcontext(0)]
        HRESULT RemoveDll([in] BSTR file);
        [id(8), helpcontext(0)]
        HRESULT SetOutPath([in] BSTR sPath);
        [id(9), helpcontext(0)]
        HRESULT SetExtendedErrOutput([in] VARIANT_BOOL boActive);
        [id(10), helpcontext(0)]
        HRESULT AddChannel([in] BSTR file, [in] BSTR channel);
        [id(11), helpcontext(0)]
        HRESULT RemoveChannel([in] BSTR file, [in] BSTR channel);
        [id(12), helpcontext(0)]
        HRESULT SetNodeName([in] BSTR file, [in] BSTR name);
        [id(13), helpcontext(0)]
        HRESULT SetConfigFile([in] BSTR file);
        [id(14), helpcontext(0)]
        HRESULT RunTest([in] BSTR project, [out, retval] VARIANT_BOOL*);
    };
 
     [
        uuid(6373169D-AED8-41DB-9617-E5C1F54E2840),
        helpstring("CAPL Class"),
        helpcontext(0)       
    ]
    coclass CAPL
    {
        [default] interface ICAPL;
    };
 
    // Definition des CanEasyApplication-Interfaces
    [
        object,
        uuid(BD4CDCBF-4B18-4CBE-8F90-8AB5087F8C99),
        dual,
        helpstring("ICanEasyApplication-Schnittstelle"),
        pointer_default(unique),
        helpcontext(756)
    ]
    interface ICanEasyApplication : IDispatch
    {
        [id(3), helpstring("Methode StartSimulation"), helpcontext(757)]
        HRESULT StartSimulation();
        [id(4), helpstring("Methode StopSimulation"), helpcontext(758)]
        HRESULT StopSimulation();
        [propget, id(5), helpstring("Eigenschaft Database"), helpcontext(759)]
        HRESULT Database([out, retval] IDatabase **pVal);        
        [id(6), helpstring("Methode Sleep"), helpcontext(760)]
        HRESULT Sleep([in] long nPeriod);
        [propget, id(12), helpstring("Eigenschaft ScreenUpdate"), helpcontext(761)]
        HRESULT ScreenUpdate([out, retval] VARIANT_BOOL *pVal);
        [propput, id(12), helpstring("Eigenschaft ScreenUpdate"), helpcontext(762)]
        HRESULT ScreenUpdate([in] VARIANT_BOOL boNewVal);
        [id(14), helpstring("Methode RegisterExtension"), hidden, restricted, helpcontext(763)] //VSTAHidden
        HRESULT RegisterExtension([in] BSTR sID, [in] IExtension* iExtension);
        [propget, id(15), helpstring("Eigenschaft Extension"), helpcontext(764)]
        HRESULT Extension([in] BSTR sID, [out, retval] IDispatch* *pVal);
        [id(16), helpstring("Methode UnregisterExtension"), hidden, restricted, helpcontext(765)] //VSTAHidden
        HRESULT UnregisterExtension([in] BSTR sID);
        [propget, id(23), helpstring("Eigenschaft SimulationIsRunning"), helpcontext(767)]
        HRESULT SimulationIsRunning([out, retval] VARIANT_BOOL* pVal);
        [propget, id(24), helpstring("Eigenschaft Simulation"), helpcontext(768)]
        HRESULT Simulation([out, retval] ISimulation **pVal);
        [propget, id(25), helpstring("Eigenschaft VarDatabase"), helpcontext(769)]
        HRESULT VarDatabase([out, retval] IEnvVarDatabase **pItem);
        [propget, id(26), helpstring("Eigenschaft Workspace Path"), helpcontext(770)]
        HRESULT WorkspacePath([out, retval] BSTR *pBSTR);
        [propget, id(27), helpstring("Eigenschaft Workspace"), helpcontext(771)]
        HRESULT Workspace([out, retval] BSTR *pBSTR);
        [propget, id(28), helpstring("Eigenschaft HardwareNames"), helpcontext(772)]
        HRESULT HardwareNames([out, retval] VARIANT* pNames);
        [id(29), helpstring("Methode MakeReport"), helpcontext(773)]
        HRESULT MakeReport([in] BSTR sReportText, [in] enum ReportType enType);
        [propget, id(30), helpstring("Eigenschaft Record"), helpcontext(774)]
        HRESULT Record([out, retval] IRecord** ppRecord);
        [propget, id(31), helpstring("Eigenschaft Application"), helpcontext(775)]
        HRESULT Application([out, retval] ICanEasyApplication** ppApp);
        [propget, id(32), helpstring("Eigenschaft Vba"), helpcontext(776)]
        HRESULT Vba([out, retval] IDispatch** ppExtension);
        [propget, id(33), helpstring("Eigenschaft CanoePanels"), helpcontext(777)]
        HRESULT CanoePanels([out, retval] ICANoePanelFactory** ppExtension);             
        [propget, id(34), helpstring("Eigenschaft RecursivEvents"), helpcontext(778)]
        HRESULT RecursivEvents([out, retval] VARIANT_BOOL *pVal);
        [propput, id(34), helpstring("Eigenschaft RecursivEvents"), helpcontext(779)]
        HRESULT RecursivEvents([in] VARIANT_BOOL boNewVal);
        [propget, id(35), helpstring("Eigenschaft VBACompatible"), helpcontext(780)]
        HRESULT VBACompatible([out, retval] VARIANT_BOOL* pVal);
        [propput, id(35), helpstring("Eigenschaft VBACompatible"), helpcontext(781)]
        HRESULT VBACompatible([in] VARIANT_BOOL boVal);
        [id(36), helpstring("Methode MakeExtendedId"), helpcontext(782)]
        HRESULT MakeExtendedId([in] long lMsgId, [out, retval] long*);
        [id(37), helpstring("Methode MakeStandardId"), helpcontext(783)]
        HRESULT MakeStandardId([in] long lMsgId, [out, retval] long*);
        [id(38), helpstring("Methode IsExtendedId"), helpcontext(784)]
        HRESULT IsExtendedId([in] long lMsgId, [out, retval] VARIANT_BOOL*);
        [id(39), helpstring("Methode GetAbsFilePath"), helpcontext(785)]
        HRESULT GetAbsFilePath([in] BSTR sAbsPath, [in] BSTR sRelPath, [out, retval] BSTR*);
        [propget, id(40), helpstring("Eigenschaft Version"), helpcontext(786)]
        HRESULT Version([out, retval] BSTR* pVersion);
        [propget, id(41), helpstring("Eigenschaft ReportWndCol"), helpcontext(787)]
        HRESULT ReportWndCol([out, retval] IReportWndCol**);
        [id(42), helpstring("Methode Init"), helpcontext(788)]
        HRESULT Init();
        [id(43), helpstring("Methode DeInit"), helpcontext(789)]
        HRESULT DeInit();
        [id(44), helpstring("Methode Start"), helpcontext(790)]
        HRESULT Start();
        [id(45), helpstring("Methode LoadWorkspace"), helpcontext(791)]
        HRESULT LoadWorkspace([in] BSTR sFile);
        [id(46), helpstring("Methode CreateObjectFilter"), helpcontext(792)]
        HRESULT CreateObjectFilter([out, retval] IObjectFilter** ppFilter);
 
        [id(47), helpstring("Methode StartInternal"), restricted, hidden]
        HRESULT StartInternal();
        [propget, id(48), helpstring("Eigenschaft License"), helpcontext(793)]
        HRESULT License([out, retval] ILicense** ppLicense);
        [id(49), helpstring("Methode CreateWorkspaceModule"), helpcontext(794)]
        HRESULT CreateWorkspaceModule([in] BSTR sModuleName, [out, retval] IWorkspaceModule**);
 
        // BTP#5828: Tree access through COM interface
        [propget, id(50), helpstring("Eigenschaft Tree"), helpcontext(795)]
        HRESULT Tree([out, retval] ICanEasyTree **pTree);
        [propget, id(52), helpstring("Eigenschaft Replay"), helpcontext(797)]
        HRESULT Replay([out, retval] IReplayCol **pReplayCol);            
        [id(53), helpstring("Methode CreateSelection"), helpcontext(798)]
        HRESULT CreateSelection([out, retval] ISelection** ppItem);
        [id(54), helpstring("Methode CreateTimerControl"), helpcontext(799)]
        HRESULT CreateTimerControl([out, retval] ITimerControl** ppItem);
        [id(55), helpstring("Methode CreateTxConfirm"), helpcontext(800)]
        HRESULT CreateTxConfirm([out, retval] ITxConfirm** ppItem);
        [id(56), helpstring("Methode CreateRxConfirm"), helpcontext(801)]
        HRESULT CreateRxConfirm([out, retval] IRxConfirm** ppItem);
        [id(57), helpstring("Methode CreatePreTransmit"), helpcontext(802)]
        HRESULT CreatePreTransmit([out, retval] IPreTransmit** ppItem);
        [id(58), helpstring("Methode CreatePreCopy"), helpcontext(803)]
        HRESULT CreatePreCopy([out, retval] IPreCopy** ppItem);
        [id(59), helpstring("Methode SaveWorkspace"), helpcontext(804)]
        HRESULT SaveWorkspace([in] BSTR sFile);
        [id(60), helpstring("Methode NewWorkspace"), helpcontext(805)]
        HRESULT NewWorkspace();
        [propget, id(61), helpstring("Methode AppWindow"), helpcontext(806)]
        HRESULT AppWindow([out, retval] IAppWindow** pVal);
        [id(62), helpstring("Methode CreateCaptureTimer"), helpcontext(807)]
        HRESULT CreateCaptureTimer([out, retval] ICaptureTimer** pItem);
        [id(63), helpstring("Methode CreateCompareTimer"), helpcontext(808)]
        HRESULT CreateCompareTimer([out, retval] ICompareTimer** pItem);
        [id(64), helpstring("Methode ShowDisclaimer"), helpcontext(809)]
        HRESULT ShowDisclaimer([out, retval] VARIANT_BOOL* pVal);
        [propget, id(65), helpstring("Property Hardware"), helpcontext(810)]
        HRESULT Hardware([out, retval] IHardware** pItem);      
        [propget, id(66), helpstring("Property VirtualChannels"), helpcontext(811)]
        HRESULT VirtualChannels([out, retval] IVirtualChannelCol** ppCol);      
 
        //  Functions for IO access
        [id(67), helpstring("Methode WritePort"), hidden, helpcontext(812)]
        HRESULT WritePort([in] long lAddr, [in] long lVal);
        [id(68), helpstring("Methode ReadPort"), hidden, helpcontext(813)]
        HRESULT ReadPort([in] long lAddr, [out, retval] long* pVal);
        [id(69), helpcontext(814)] HRESULT CreateSerialPort([out, retval] ISerialPort** pVal);
        [id(70), helpcontext(815)] HRESULT Transmit([in] IDatabaseItem* pItem);
        [id(71), helpstring("Quit from application"), helpcontext(816)]
        HRESULT Quit();
        [id(72), helpstring("Creates DatabaseItem object"), helpcontext(0)]
        HRESULT CreateDatabaseItem([out, retval] IDatabaseItemBase** ppItem);
        [id(73)] HRESULT CalculateKey([in] BSTR dll, [in] long secLevel, [in] BSTR variant, [in] VARIANT seed, [out, retval] VARIANT*);
        [id(74)] HRESULT CalculateKeyOpt([in] BSTR dll, [in] long secLevel, [in] BSTR variant, [in] BSTR option, [in] VARIANT seed, [out, retval] VARIANT*);
        [propget, id(75), helpcontext(0)]
        HRESULT CAPL([out, retval] ICAPL** ppCAPL);
        [id(76), helpcontext(0)]
        HRESULT WriteSetting([in] BSTR sName, [in] VARIANT_BOOL iniFile, [in] BSTR sVal);
        [id(77), helpcontext(0)]
        HRESULT ReadSetting([in] BSTR sName, [in] VARIANT_BOOL iniFile, [out, retval] BSTR*);
        [id(78), helpcontext(0)]
        HRESULT TransmitStringData([in] BSTR sRef, [in] BSTR data, [out, retval] BSTR*);
        [id(79), helpcontext(0)]
        HRESULT Flash([in] BSTR sProps, [out, retval] long*);
    };       
 
    [
        uuid(07643057-645A-4CF8-91EE-47B2449015B8),
        helpstring("_ICanDllEreignisschnittstelle"),
        helpcontext(826)
    ]
    dispinterface _ICanEasyApplicationEvents
    {
    properties:
    methods:
    };
 
    [
        uuid(9579DE1C-3F4D-405B-BA88-062BA42315C5),
        helpstring("CanEasyApplication Class"),
        appobject,
        helpcontext(827)
    ]
    coclass CanEasyApplication
    {
        [default] interface ICanEasyApplication;
        [default, source] dispinterface _ICanEasyApplicationEvents;
    };
 
    interface ITransmissionData;
 
    //
    //      Pre-Transmit
    //
 
    [
        object,
        uuid(C400E402-0BB9-41b5-AC51-3D6BA7F0A0CB),
        dual,
        nonextensible,
        helpstring("IPreTransmit-Schnittstelle"),
        pointer_default(unique),
        helpcontext(846)
    ]
    interface IPreTransmit : IDispatch
    {
        [id(1), helpstring("Methode Filter"), helpcontext(847)]
        HRESULT Filter([in] BSTR sFilter, [in] BSTR sId, [in] enum CallbackPosition enPosition, [in] IDatabaseItem* pItem);
        [propget, id(2), helpstring("Eigenschaft Active"), helpcontext(848)]
        HRESULT Active([out, retval] VARIANT_BOOL* pVal);
        [propput, id(2), helpstring("Eigenschaft Active"), helpcontext(849)]
        HRESULT Active([in] VARIANT_BOOL boVal);
    };  
 
    [
        uuid(271A1308-CE97-4219-8011-95BBDCE9CD5C),
        helpstring("_IPreTransmit Ereignisschnittstelle"),
        helpcontext(850)
    ]
    dispinterface _IPreTransmitEvents
    {
    properties:
    methods:   
        [id(10), helpstring("Methode OnPreTransmit - Wird vom COM-Thread aufgerufen."), helpcontext(851)]
        HRESULT OnPreTransmit([in] TransmissionData* pTransmission, [in] IBoolValue* pAllowSend);
        [id(31), helpstring("Methode OnPreTransmitSync - Wird vom Auslöser-Thread aufgerufen."), restricted, hidden, helpcontext(852)]
        HRESULT OnPreTransmitSync([in] TransmissionData* pTransmission, [in] IBoolValue* pAllowSend);
    };
 
    [
        uuid(EB51F24F-8BD7-48dd-897D-D5E4ECC927C8),
        helpstring("PreTransmit Class"),
        helpcontext(853)
    ]
    coclass PreTransmit
    {
        [default] interface IPreTransmit;
        [default, source] dispinterface _IPreTransmitEvents;
    };
 
    //
    //       PreCopy
    //
 
    [
        object,
        uuid(BD239A0A-8B65-41da-A54D-973741225B3B),
        dual,
        nonextensible,
        helpstring("IPreCopy-Schnittstelle"),
        pointer_default(unique),
        helpcontext(854)
    ]
    interface IPreCopy : IDispatch
    {
        [id(1), helpstring("Methode Filter"), helpcontext(855)]
        HRESULT Filter([in] BSTR sFilter, [in] BSTR sId, [in] enum CallbackPosition enPosition, [in] IDatabaseItem* pItem);
        [propget, id(2), helpstring("Eigenschaft Active"), helpcontext(856)]
        HRESULT Active([out, retval] VARIANT_BOOL* pVal);
        [propput, id(2), helpstring("Eigenschaft Active"), helpcontext(857)]
        HRESULT Active([in] VARIANT_BOOL boVal);
    };  
 
    [
        uuid(4C15974C-C2E1-4a1c-ACB6-DD154A13BE6C),
        helpstring("_IPreCopy Ereignisschnittstelle"),
        helpcontext(858)
    ]
    dispinterface _IPreCopyEvents
    {
    properties:
    methods:   
        [id(11), helpstring("Methode OnPreCopy - Wird vom COM-Thread aufgerufen."), helpcontext(859)]
        HRESULT OnPreCopy([in] TransmissionData* pTransmission, [in] BoolValue* pAllowSend);
        [id(32), helpstring("Methode OnPreCopySync - Wird vom Auslöser-Thread aufgerufen."), restricted, hidden, helpcontext(860)]
        HRESULT OnPreCopySync([in] TransmissionData* pTransmission,  [in] BoolValue* pAllowSend);
    };
 
    [
        uuid(FFF19EAE-0EE1-45de-9A2F-98A9DF920C5E),
        helpstring("PreCopy Class"),
        helpcontext(861)
    ]
    coclass PreCopy
    {
        [default] interface IPreCopy;
        [default, source] dispinterface _IPreCopyEvents;
    };
 
   //
   //       Tx-Confirm
   //
 
   [
      object,
      uuid(7037B8BC-B8EA-4f63-B8FE-49119EE3338B),
      dual,
      nonextensible,
      helpstring("ITxConfirm-Schnittstelle"),
      pointer_default(unique),
      hidden,
      helpcontext(862)
   ]
   interface ITxConfirm : IDispatch
   {
      [id(1), helpstring("Methode Filter"), helpcontext(863)]
      HRESULT Filter([in] BSTR sFilter, [in] BSTR sId, [in] enum CallbackPosition enPosition, [in] IDatabaseItem* pItem);
      [propget, id(2), helpstring("Eigenschaft Asynchron"), helpcontext(864)]
      HRESULT Asynchron([out,retval] VARIANT_BOOL*);
      [propput, id(2), helpstring("Eigenschaft Asynchron"), helpcontext(865)]
      HRESULT Asynchron([in] VARIANT_BOOL boNewVal);
      [propget, id(3), helpstring("Eigenschaft Active"), helpcontext(866)]
      HRESULT Active([out, retval] VARIANT_BOOL* pVal);
      [propput, id(3), helpstring("Eigenschaft Active"), helpcontext(867)]
      HRESULT Active([in] VARIANT_BOOL boVal);
   };  
 
   [
      uuid(52C7020F-6E55-436b-8122-A85D81630857),
      helpstring("_ITxConfirm Ereignisschnittstelle"),
      helpcontext(868)
   ]
   dispinterface _ITxConfirmEvents
   {
   properties:
   methods:   
       [id(12), helpstring("Methode OnTxConfirm - Wird vom COM-Thread aufgerufen."), helpcontext(869)]
      HRESULT OnTxConfirm([in] TransmissionData* pTransmission);
       [id(33), helpstring("Methode OnTxConfirmSync - Wird vom Auslöser-Thread aufgerufen."), restricted, hidden, helpcontext(870)]
      HRESULT OnTxConfirmSync([in] TransmissionData* pTransmission);
   };
 
   [
      uuid(FD5CD329-1E26-4162-8447-61ACCBB8224B),
      helpstring("TxConfirm Class"),
      hidden,
      helpcontext(871)
   ]
   coclass TxConfirm
   {
      [default] interface ITxConfirm;
      [default, source] dispinterface _ITxConfirmEvents;
   };
 
   //
   //       Rx-Confirm
   //
 
   [
      object,
      uuid(E0F2E98E-0A6B-441c-BF1A-E075D87BA24D),
      dual,
      nonextensible,
      helpstring("IRxConfirm-Schnittstelle"),
      pointer_default(unique),
      hidden,
      helpcontext(872)
   ]
   interface IRxConfirm : IDispatch
   {
      [id(1), helpstring("Methode Filter"), helpcontext(873)]
      HRESULT Filter([in] BSTR sFilter, [in] BSTR sId, [in] enum CallbackPosition enPosition, [in] IDatabaseItem* pItem);
      [propget, id(2), helpstring("Eigenschaft Asynchron"), helpcontext(874)]
      HRESULT Asynchron([out,retval] VARIANT_BOOL*);
      [propput, id(2), helpstring("Eigenschaft Asynchron"), helpcontext(875)]
      HRESULT Asynchron([in] VARIANT_BOOL boNewVal);
      [propget, id(3), helpstring("Eigenschaft Active"), helpcontext(876)]
      HRESULT Active([out, retval] VARIANT_BOOL* pVal);
      [propput, id(3), helpstring("Eigenschaft Active"), helpcontext(877)]
      HRESULT Active([in] VARIANT_BOOL boVal);
   };  
 
   [
      uuid(4DE3C021-0B8F-4100-B6A0-B37335BCEE2F),
      helpstring("_IRxConfirm Ereignisschnittstelle"),
      helpcontext(878)
   ]
   dispinterface _IRxConfirmEvents
   {
   properties:
   methods:   
       [id(13), helpstring("Methode OnRxConfirm - Wird vom COM-Thread aufgerufen."), helpcontext(879)]
      HRESULT OnRxConfirm([in] TransmissionData* pTransmission);
       [id(34), helpstring("Methode OnRxConfirmSync - Wird vom Auslöser-Thread aufgerufen."), restricted, hidden, helpcontext(880)]
      HRESULT OnRxConfirmSync([in] TransmissionData* pTransmission);
   };
 
   [
      uuid(0F206A5E-FE8E-466a-9951-F423F7BF365E),
      helpstring("RxConfirm Class"),
      hidden,
      helpcontext(881)
   ]
   coclass RxConfirm
   {
      [default] interface IRxConfirm;
      [default, source] dispinterface _IRxConfirmEvents;
   };
 
    [
        object,
        uuid(D0FF3D65-4BC5-49b3-B872-ABF91B191820),
        dual,
        nonextensible,
        helpstring("ITransmissionData-Schnittstelle"),
        pointer_default(unique),
        helpcontext(882)
    ]
    interface ITransmissionData : IDispatch
    {
        [propget, id(1), helpstring("Eigenschaft Bus"), helpcontext(883)]
        HRESULT Bus([out, retval] IBus** ppBus);
        [propget, id(2), helpstring("Eigenschaft Message"), helpcontext(884)]
        HRESULT Message([out, retval] IMessage** ppMsg);
        [id(3), helpstring("Methode GetMsgId"), hidden, helpcontext(885)]
        HRESULT GetMsgId([out, retval] IMessageId** ppMsgId);
        [propget, id(4), helpstring("Eigenschaft Dlc"), helpcontext(886)]
        HRESULT Dlc([out, retval] byte* pDlc);
        [propget, id(5), helpstring("Eigenschaft Timestamp"), helpcontext(887)]
        HRESULT Timestamp([out, retval] double* pTimestamp);
        [propget, id(6), helpstring("Eigenschaft Data"), helpcontext(888)]
        HRESULT Data([out, retval] IMsgData** ppData);
        [propget, id(7), helpstring("Eigenschaft MsgId"), helpcontext(889)]
        HRESULT MsgId([out, retval] IMessageId** ppMsgId);
        [propget, id(8), helpstring("Eigenschaft Received"), helpcontext(890)]
        HRESULT Received([out, retval] VARIANT_BOOL* pVal);
        [propget, id(9), helpstring("Eigenschaft ErrorNo"), helpcontext(889)]
        HRESULT ErrorNo([out, retval] LONG* pErrorNo);
        [propget, id(10), helpstring("Eigenschaft ErrorText"), helpcontext(890)]
        HRESULT ErrorText([out, retval] BSTR* pErrorText);
        [propget, id(11), helpstring("Eigenschaft DBItem"), helpcontext(884)]
        HRESULT DBItem([out, retval] IDatabaseItem** ppDBItem);
        [propget, id(12), helpstring("Eigenschaft Timeout"), helpcontext(0)]
        HRESULT Timeout([out, retval] VARIANT_BOOL* timeout);
        [propget, id(13), helpstring("Eigenschaft Flags"), helpcontext(0)]
        HRESULT Flags([out, retval] enum TransmissionFlags* timeout);
    };
 
    [
        uuid(D0FF3D65-4BC5-49b3-B872-ABF91B191821),
        helpstring("TransmissionData Class"),
        helpcontext(891)
    ]
    coclass TransmissionData
    {
        [default] interface ITransmissionData;      
    };
 
    [
        dual,
        object,
        uuid(4FC64079-2DE9-4571-94E6-D4EFC5F149D3),
        helpstring("IVstaIntegration Schnittstelle"),
        nonextensible,
        pointer_default(unique),
        helpcontext(894),
        hidden
    ]
    interface IVstaIntegration : IDispatch
    {
        [id(1), helpstring("Methode Connect"), helpcontext(895)]
        HRESULT Connect([in] IOMAgent* pCanDll);
        [id(2), helpstring("Methode Disconnect"), helpcontext(896)]
        HRESULT Disconnect();
        [id(3), helpstring("Methode NewAddIn"), helpcontext(897)]
        HRESULT NewAddIn([in] BSTR sPath, [in] enum AddInLanguage enLang);
        [id(4), helpstring("Methode LoadAddIn"), helpcontext(898)]
        HRESULT LoadAddIn([in] BSTR sPath);
        [id(5), helpstring("Methode UnloadAddIn"), helpcontext(899)]
        HRESULT UnloadAddIn([in] BSTR sPath);
        [id(6), helpstring("Methode ShowIde"), helpcontext(900)]
        HRESULT ShowIde([in] VARIANT_BOOL boShow);
        [propget, id(7), helpstring("Eigenschaft CallGotDirtyOnFilechanges"), helpcontext(901)]
        HRESULT CallGotDirtyOnFilechanges([out, retval] VARIANT_BOOL* boCall);
        [propput, id(7), helpstring("Eigenschaft CallGotDirtyOnFilechanges"), helpcontext(902)]
        HRESULT CallGotDirtyOnFilechanges([in] VARIANT_BOOL boCall);
        [id(8), helpstring("Eigenschaft AddIns"), helpcontext(903)]
        HRESULT GetAddIns([out] VARIANT* pAddInPaths);
        [id(9), helpstring("Methode CleanDirty"), helpcontext(904)]
        HRESULT CleanDirty();
        [propget, id(10), helpstring("Eigenschaft Dirty"), helpcontext(905)]
        HRESULT Dirty([out, retval] VARIANT_BOOL* pAddInPaths);
        [id(11), helpstring("Methode StartAddIn"), helpcontext(906)]
        HRESULT StartAddIn([in] BSTR sPath);
        [id(12), helpstring("Methode StopAddIn"), helpcontext(907)]
        HRESULT StopAddIn([in] BSTR sPath);
        [id(13), helpstring("Methode GetAddInStatus"), helpcontext(908)]
        HRESULT GetAddInStatus([in] BSTR sPath, [out] enum AddInStatus* pStatus);
        [id(14), helpstring("Methode SaveDirtyAddIns"), helpcontext(909)]
        HRESULT SaveDirtyAddIns();
        [id(15), helpstring("Starts add-in and returns list of its macros names. When an add-in keeps running, its macro (static method) can be started."), helpcontext(910)]
        HRESULT StartAddInExt([in] BSTR sPath, [out] VARIANT * sMacroNames);
        [id(16), helpstring("Starts add-in's macro determined by sPath path string. Before the start an add-in must be started with StartAddInExt function. If macro requires input parameters and/or returns a value, a modal dialog will be shown with hParentWindow as parent."), helpcontext(911)]
        HRESULT StartMacro([in] BSTR sPath, [in] BSTR sMacroName, [in] LONG hParentWindow);
    };
 
    [
        uuid(1405AE55-EA21-4ed2-B993-4A63FCBE6CF2),
        helpstring("_IVstaIntegration Ereignisschnittstelle"),
        helpcontext(912)
    ]
    dispinterface _IVstaIntegrationEvents
    {
    properties:
    methods:   
        [id(1), helpstring("Methode OnAddInClosed"), helpcontext(913)]
        HRESULT OnAddInClosed([in] BSTR sAddIn);
        [id(2), helpstring("Methode OnAddInOpened"), helpcontext(914)]
        HRESULT OnAddInOpened([in] BSTR sAddIn);
        [id(3), helpstring("Methode OnAddInNameChanged"), helpcontext(915)]
        HRESULT OnAddInPathChanged([in] BSTR sOldPath, [in] BSTR sNewPath);
        [id(4), helpstring("Methode OnGotDirty"), helpcontext(916)]
        HRESULT OnGotDirty();
        [id(5), helpstring("Methode OnAddInStatusChanged"), helpcontext(917)]
        HRESULT OnAddInStatusChanged([in] BSTR sAddIn, [in] enum AddInStatus enStatus);
    };
 
    [
        dual,
        object,
        uuid(4C402E2B-7071-4709-9534-935B5206FBDF),
        helpstring("IShortcut Schnittstelle"),
        nonextensible,
        pointer_default(unique),
        helpcontext(919)
    ]
    interface IShortcut : IDispatch
    {
        [propput, id(1), helpstring("Eigenschaft Key"), helpcontext(920)]
        HRESULT Key([in] long lKey);
        [propget, id(1), helpstring("Eigenschaft Key"), helpcontext(921)]
        HRESULT Key([out, retval] long* pKey);
        [propput, id(2), helpstring("Eigenschaft Modifier"), helpcontext(922)]
        HRESULT Modifier([in] enum KeyModifier enModifier);
        [propget, id(2), helpstring("Eigenschaft Modifier"), helpcontext(923)]
        HRESULT Modifier([out, retval] enum KeyModifier* pModifier);
        [propput, id(3), helpstring("Eigenschaft SystemScope"), helpcontext(924)]
        HRESULT SystemScope([in] VARIANT_BOOL systemScope);
        [propget, id(3), helpstring("Eigenschaft SystemScope"), helpcontext(925)]
        HRESULT SystemScope([out, retval] VARIANT_BOOL* pSystemScope);
    };
 
    [
        uuid(C3599ACC-A077-4a87-91C6-710485A62AEC),
        helpstring("_IShortcutEvents Ereignisschnittstelle"),
        helpcontext(926)
    ]
    dispinterface _IShortcutEvents
    {
    properties:
    methods:   
        [id(1), helpstring("Methode OnShortcut - Wird vom COM-Thread aufgerufen."), helpcontext(927)]
        HRESULT OnShortcut([in] long lKey, [in] enum KeyModifier enModifier);
        [id(30), helpstring("Methode OnShortcutSync - Wird vom Auslöser-Thread aufgerufen."), restricted, hidden, helpcontext(928)]
        HRESULT OnShortcutSync([in] long lKey, [in] enum KeyModifier enModifier);
    };
 
    [
        uuid(E4993B0A-4A69-4bed-9BA3-4309B96D988F),
        helpstring("Shortcut Class"),
        helpcontext(929)
    ]
    coclass Shortcut
    {
        [default] interface IShortcut;
        [default, source] dispinterface _IShortcutEvents;
    };
 
    [
        object,
        uuid(DB77A495-D0D8-4b43-B121-7E782E28C4A9),
        dual,
        helpstring("IWorkspaceModule-Schnittstelle"),
        pointer_default(unique),
        hidden,
        helpcontext(930)
    ]
    interface IWorkspaceModule : IDispatch
    {
        [propget, id(1), helpstring("Eigenschaft Workspace Path"), helpcontext(931)]
        HRESULT WorkspacePath([out, retval] BSTR *pBSTR);
        [propget, id(2), helpstring("Eigenschaft Workspace"), helpcontext(932)]
        HRESULT Workspace([out, retval] BSTR *pBSTR);
        [propget, id(3), helpstring("Eigenschaft ModuleName"), helpcontext(933)]
        HRESULT ModuleName([out, retval] BSTR *pName);      
        [propput, id(4), helpstring("Eigenschaft ModuleData"), helpcontext(934)]
        HRESULT ModuleData([in] VARIANT vData);
        [id(5), helpstring("Methode ReloadModuleData"), helpcontext(935)]
        HRESULT ReloadModuleData();
    };
 
    [
        uuid(FA34E686-AA0A-4df9-A067-8C582C78ED04),
        helpstring("_IWorkspaceModuleEreignisschnittstelle"),
        helpcontext(936)
    ]
    dispinterface _IWorkspaceModuleEvents
    {
    properties:
    methods:
        [id(1), helpstring("Methode OnLoadWorkspace - Wird vom Besitzer-Thread aufgerufen."), helpcontext(937)]
        HRESULT OnLoadWorkspace([in] VARIANT vSavedData, [in] BoolValue *pSuccess);
        [id(2), helpstring("Methode OnSaveWorkspace - Wird vom Besitzer-Thread aufgerufen."), helpcontext(938)]
        HRESULT OnSaveWorkspace([in] BoolValue *pSaved);
        [id(3), helpstring("Methode OnUnLoadWorkspace - Wird vom Besitzer-Thread aufgerufen."), helpcontext(939)]
        HRESULT OnUnLoadWorkspace();
        [id(4), helpstring("Methode OnNewWorkspace - Wird vom Besitzer-Thread aufgerufen."), helpcontext(940)]
        HRESULT OnNewWorkspace();
        [id(30), helpstring("Methode OnLoadWorkspaceSync - Wird vom Auslöser-Thread aufgerufen."), restricted, hidden, helpcontext(941)]
        HRESULT OnLoadWorkspaceSync([in] VARIANT vSavedData, [in] BoolValue *pSuccess);
        [id(31), helpstring("Methode OnSaveWorkspaceSync - Wird vom Auslöser-Thread aufgerufen."), restricted, hidden, helpcontext(942)]
        HRESULT OnSaveWorkspaceSync([in] BoolValue *pSaved);
        [id(32), helpstring("Methode OnUnLoadWorkspaceSync - Wird vom Auslöser-Thread aufgerufen."), restricted, hidden, helpcontext(943)]
        HRESULT OnUnLoadWorkspaceSync();
        [id(33), helpstring("Methode OnNewWorkspaceSync - Wird vom Auslöser-Thread aufgerufen."), restricted, hidden, helpcontext(944)]
        HRESULT OnNewWorkspaceSync();
    };
 
    [
        uuid(F2BAA8F6-27EB-44a2-B14D-D49A4482DCE1),
        helpstring("WorkspaceModule Class"),
        helpcontext(945)
    ]
    coclass WorkspaceModule
    {
        [default] interface IWorkspaceModule;
        [default, source] dispinterface _IWorkspaceModuleEvents;
    };
 
 
    //
    //       Hardware-Interface
    //
 
    interface IHardwareConfigurationCol;
    interface IDeviceCol;
    interface IDevice;
 
    [
        object,
        uuid(03481CD1-560B-478A-AEAA-8EBF0CCF81BC),
        dual,
        helpstring("IHardware-Schnittstelle"),
        nonextensible,
        pointer_default(unique),
        helpcontext(950)
    ]
    interface IHardware : IDispatch
    {
        [id(1), helpstring("Methode RefreshDeviceList"), helpcontext(951)]
        HRESULT RefreshDevices();
        [propget, id(2), helpstring("Property VendorList"), helpcontext(952)]
        HRESULT Vendors([out, retval] VARIANT *pVendors);
        [propget, id(3), helpstring("Property DeviceList"), helpcontext(953)]
        HRESULT Devices([in] BSTR sVendor, [out, retval] VARIANT *pDevices);
        [propget, id(4), helpstring("Property Configurations"), helpcontext(954)]
        HRESULT Configurations([out, retval] IHardwareConfigurationCol**);      
    };
 
    [
        uuid(78E47A91-78EA-4C72-9522-D76CD52D2A38),
        helpstring("Hardware Class"),
        helpcontext(955)
    ]
    coclass Hardware
    {
        [default] interface IHardware;
    };
   
    [
        object,
        uuid(B23BAE88-E733-4E47-B59B-12FCA0D13CB6),
        dual,
        helpstring("IHardwareConfiguration-Interface"),
        nonextensible,
        pointer_default(unique),
        helpcontext(956)
    ]
    interface IHardwareConfiguration : IDispatch
    {
        [propget, id(DISPID_VALUE), helpstring("Property Name"), helpcontext(957)] 
        HRESULT Name([out, retval] BSTR *sName);
        [propput, id(DISPID_VALUE), helpstring("Property Name"), helpcontext(958)] 
        HRESULT Name([in] BSTR sName);   
        [propget, id(1), helpstring("Property Active"), helpcontext(959)]
        HRESULT Active([out, retval] VARIANT_BOOL *pActive);
        [propput, id(1), helpstring("Property Active"), helpcontext(960)]
        HRESULT Active([in] VARIANT_BOOL boActive);
        [propget, id(2), helpstring("Property ActiveForWorkspace"), helpcontext(961)]
        HRESULT ActiveForWorkspace([out, retval] VARIANT_BOOL *pActive);
        [propput, id(2), helpstring("Property ActiveForWorkspace"), helpcontext(962)]
        HRESULT ActiveForWorkspace([in] VARIANT_BOOL boActive);
        [id(3), helpstring("Method Delete"), helpcontext(963)]
        HRESULT Delete();
        [id(4), helpstring("Method AddDevice"), helpcontext(964)]
        HRESULT AddDevice([in] BSTR sVendor, [in] BSTR sDevice, [in] BSTR sDeviceId, [out, retval] IDevice**);
        [id(5), helpstring("Method DeleteDevice"), helpcontext(965)]
        HRESULT DeleteDevice([in] BSTR sVendor, [in] BSTR sDevice, [in] BSTR sDeviceId);            
        [id(6), helpstring("Method Export"), helpcontext(966)]
        HRESULT Export([in] BSTR sFile);
        [propget, id(7), helpstring("Property Devices"), helpcontext(967)]
        HRESULT Devices([out, retval] IDeviceCol**);
    };
    
    [
        uuid(D8A7E480-BDA2-4B0D-8204-4442BADF227C),
        helpstring("HardwareConfiguration Class"),
        helpcontext(968)
    ]
    coclass HardwareConfiguration
    {
        [default] interface IHardwareConfiguration;
    };
 
    [
        object,
        uuid(24BC19C7-169C-4BFE-89C1-789FD4CBAA6B),
        dual,
        helpstring("IHardwareConfigurationCol-Interface"),
        nonextensible,
        pointer_default(unique),
        helpcontext(969)
    ]
    interface IHardwareConfigurationCol : IDispatch
    {
        [propget, id(DISPID_NEWENUM), helpstring("Property _NewEnum"), restricted, hidden, helpcontext(970)] //VSTAHidden
        HRESULT _NewEnum([out, retval] IUnknown** ppItem); 
        [propget, id(DISPID_VALUE), helpstring("Property Item"), helpcontext(971)]
        HRESULT Item([in] VARIANT vIndex, [out, retval] IHardwareConfiguration**);
        [propget, id(1), helpstring("Property Workstation"), helpcontext(972)]
        HRESULT Workstation([out, retval] IHardwareConfiguration**);
        [id(2), helpstring("Method AddEmptyConfiguration"), helpcontext(973)]
        HRESULT AddEmptyConfiguration([in] BSTR sName, [out, retval] IHardwareConfiguration**);
        [id(3), helpstring("Method AddCopyOfConfiguration"), helpcontext(974)]
        HRESULT AddCopyOfConfiguration([in] BSTR sName, [in] IHardwareConfiguration* pBase, [out, retval] IHardwareConfiguration**);        
        [id(4), helpstring("Method Import"), helpcontext(975)]
        HRESULT Import([in] BSTR sFile);
        [id(5), helpstring("Method Export"), helpcontext(976)]
        HRESULT Export([in] BSTR sFile);
        [id(6), helpstring("Method Delete"), helpcontext(977)]
        HRESULT Delete();
        [propget, id(7), helpstring("Property Count"), helpcontext(978)]
        HRESULT Count([out, retval] LONG* pCount);
    };
 
    [
        uuid(A8221370-40B7-486D-900D-B45233900F2C),
        helpstring("HardwareConfigurationCol Class"),
        helpcontext(979)
    ]
    coclass HardwareConfigurationCol
    {
        [default] interface IHardwareConfigurationCol;
    };
   
    [
        object,
        uuid(1A2628A7-BACD-481D-B984-B361EC590A2B),
        dual,
        helpstring("IVirtualChannel-Interface"),
        nonextensible,
        pointer_default(unique),
        helpcontext(980)
    ]
    interface IVirtualChannel : IDispatch
    {
        [propget, id(1), helpstring("Property BusType"), helpcontext(981)]
        HRESULT BusType([out, retval] enum BusType* pType);
        [propget, id(2), helpstring("Property Channel"), helpcontext(982)]
        HRESULT Channel([out, retval] LONG* pVal);
        [id(3), helpstring("Method Delete"), helpcontext(983)]
        HRESULT Delete();
    };
 
    [
        uuid(7EE97F0E-C3C3-4D62-A435-0FEA1E9A7540),
        helpstring("VirtualChannel Class"),
        helpcontext(984)
    ]
    coclass VirtualChannel
    {
        [default] interface IVirtualChannel;
    };
 
    [
        object,
        uuid(24BE70AA-A0C9-461B-85E4-1CA7E1BA745F),
        dual,
        helpstring("IVirtualChannelCol-Interface"),
        nonextensible,
        pointer_default(unique),
        helpcontext(985)
    ]
    interface IVirtualChannelCol : IDispatch
    {
        [propget, id(DISPID_NEWENUM), helpstring("Property _NewEnum"), restricted, hidden, helpcontext(986)] //VSTAHidden
        HRESULT _NewEnum([out, retval] IUnknown** ppItem); 
        [propget, id(DISPID_VALUE), helpstring("Property Item"), helpcontext(987)]
        HRESULT Item([in] LONG lIndex, [out, retval] IVirtualChannel** ppChannel);
        [propget, id(1), helpstring("Property Count"), helpcontext(988)]
        HRESULT Count([out, retval] LONG* pCount);
        [id(2), helpstring("Method Delete"), helpcontext(989)]
        HRESULT Delete();
    };
 
    [
        uuid(EDAE73AE-12C7-4EDD-89C0-2886F176C112),
        helpstring("VirtualChannelCol Class"),
        helpcontext(990)
    ]
    coclass VirtualChannelCol
    {
        [default] interface IVirtualChannelCol;
    };
 
    interface IDeviceChannelCol;
 
    [
        object,
        uuid(5FF074F5-3EA7-4A6C-8BDF-250EBEB99CDC),
        dual,
        helpstring("IDevice-Interface"),
        nonextensible,
        pointer_default(unique),
        helpcontext(991)
    ]
    interface IDevice : IDispatch
    {
        [propget, id(DISPID_VALUE), helpstring("Property Name"), helpcontext(992)]
        HRESULT Name([out, retval] BSTR *pName);      
        [propget, id(1), helpstring("Property Vendor"), helpcontext(993)]
        HRESULT Vendor([out, retval] BSTR *pName);
        [propget, id(2), helpstring("Property DeviceId"), helpcontext(994)]
        HRESULT DeviceId([out, retval] BSTR* pDeviceId);
        [propget, id(3), helpstring("Property Channels"), helpcontext(995)]
        HRESULT Channels([out, retval] IDeviceChannelCol** ppCol);
    };
 
    [
        uuid(CC6FDBD4-A179-4739-8A7D-8730A8907F49),
        helpstring("Device Class"),
        helpcontext(996)
    ]
    coclass Device
    {
        [default] interface IDevice;
    };
 
    [
        object,
        uuid(8E81467B-9734-4316-9DF9-052A1EDDCC45),
        dual,
        helpstring("IDeviceCol-Interface"),
        nonextensible,
        pointer_default(unique),
        helpcontext(997)
    ]
    interface IDeviceCol : IDispatch
    {
        [propget, id(DISPID_NEWENUM), helpstring("Property _NewEnum"), restricted, hidden, helpcontext(998)] //VSTAHidden
        HRESULT _NewEnum([out, retval] IUnknown** ppItem); 
        [propget, id(DISPID_VALUE), helpstring("Property Item"), helpcontext(999)]
        HRESULT Item([in] LONG lIndex, [out, retval] IDevice**);
        [propget, id(1), helpstring("Property Count"), helpcontext(1000)]
        HRESULT Count([out, retval] LONG* pCount);
        [id(2), helpstring("Method Delete"), helpcontext(1001)]
        HRESULT Delete();
        [id(3), helpstring("Method Add"), helpcontext(1002)]
        HRESULT Add([in] BSTR sVendor, [in] BSTR sDevice, [in] BSTR sDeviceId, [out, retval] IDevice**);
    };
 
    [
        uuid(BDABC872-5A9B-4FC8-ADE2-6AA70334248B),
        helpstring("DeviceCol Class"),
        helpcontext(1003)
    ]
    coclass DeviceCol
    {
        [default] interface IDeviceCol;
    };
 
    [
        object,
        uuid(FAEE8897-1D29-450C-8BE5-EB25D1000B74),
        dual,
        helpstring("IDeviceChannel-Interface"),
        nonextensible,
        pointer_default(unique),
        helpcontext(1004)
    ]
    interface IDeviceChannel : IDispatch
    {
        [propget, id(1), helpstring("Property VirtualChannels"), helpcontext(1005)]
        HRESULT VirtualChannels([out, retval] IVirtualChannelCol** ppCol);
        [propget, id(2), helpstring("Property BusType"), helpcontext(1006)]
        HRESULT BusType([out, retval] enum BusType* pType);
        [id(3), helpstring("Method Connect"), helpcontext(1007)]
        HRESULT Connect([in] IVirtualChannel* pChannel);
    };
 
    [
        uuid(E50523DB-84BF-4A40-84CF-3DC8D91FC2CF),
        helpstring("DeviceChannel Class"),
        helpcontext(1008)
    ]
    coclass DeviceChannel
    {
        [default] interface IDeviceChannel;
    };
 
    [
        object,
        uuid(50374A8C-BFF6-47D9-A0A8-994245CA44B5),
        dual,
        helpstring("IDeviceChannelCol-Interface"),
        nonextensible,
        pointer_default(unique),
        helpcontext(1009)
    ]
    interface IDeviceChannelCol : IDispatch
    {
        [propget, id(DISPID_NEWENUM), helpstring("Property _NewEnum"), restricted, hidden, helpcontext(1010)] //VSTAHidden
        HRESULT _NewEnum([out, retval] IUnknown** ppItem); 
        [propget, id(DISPID_VALUE), helpstring("Property Item"), helpcontext(1011)]
        HRESULT Item([in] LONG index, [out, retval] IDeviceChannel** ppChannel);
        [propget, id(1), helpstring("Property Count"), helpcontext(1012)]
        HRESULT Count([out, retval] LONG* pCount);
    };
 
    [
        uuid(1BDAE107-F8C0-4EB4-BCE8-DD85129D28ED),
        helpstring("DeviceChannelCol Class"),
        helpcontext(1013)
    ]
    coclass DeviceChannelCol
    {
        [default] interface IDeviceChannelCol;
    };
 
    //
    //       Stack
    //
 
    [
        object,
        uuid(A1219A8A-F447-450F-BCCB-06AFC03C3F39),
        dual,
        helpstring("IStaticServiceParam-Interface"),
        nonextensible,
        pointer_default(unique),
        helpcontext(0)
    ]
    interface IStaticServiceParam : IStaticDataEntry
    {
    };
 
    [
        uuid(018C269C-4677-4EDA-B434-75D2F44B2BF7),
        helpstring("StaticServiceParam Class"),
        helpcontext(0)
    ]
    coclass StaticServiceParam
    {
        [default] interface IStaticServiceParam;
        [default, source] dispinterface _IDataEntryBaseEvents;
    };
 
    [
        object,
        uuid(664C1991-E4AB-4EE4-88FC-A3B6E7D11454),
        dual,
        helpstring("IDynamicServiceParam-Interface"),
        nonextensible,
        pointer_default(unique),
        helpcontext(0)
    ]
    interface IDynamicServiceParam : IDynamicDataEntry
    {
    };
 
    [
        uuid(778F92B2-3884-4D4E-9E97-FC65E46C7CDE),
        helpstring("DynamicServiceParam Class"),
        helpcontext(0)
    ]
    coclass DynamicServiceParam
    {
        [default] interface IDynamicServiceParam;
        [default, source] dispinterface _IDataEntryBaseEvents;
    };
 
    [
        object,
        uuid(AB0D4762-182E-4FD7-B75E-6CB4A791D451),
        dual,
        helpstring("IServiceParamCol-Interface"),
        nonextensible,
        pointer_default(unique),
        helpcontext(0)
    ]
    interface IServiceParamCol : IDataEntryColBase
    {
        [id(2), helpstring("Methode AddParam"), helpcontext(0)]
        HRESULT AddStaticParam([in] BSTR sName, [in] long lStartBits, [in] long lBitCount, [in] enum ByteOrder enByteOrder, [out, retval] IStaticServiceParam**);
        [id(4), helpstring("Methode AddParam"), helpcontext(0)]
        HRESULT AddDynamicParam([in] BSTR sName, [in] long lStartByte, [in] long lByteCount, [in] enum ByteOrder enByteOrder, [out, retval] IDynamicServiceParam**);
    };
 
    [
        uuid(48744C4A-50E7-4125-897C-C9D69FD08F2A),
        helpstring("ServiceParamCol Class"),
        helpcontext(0)
    ]
    coclass ServiceParamCol
    {
        [default] interface IServiceParamCol;
    }; 
 
    [
        object,
        uuid(C7ACDCD0-04BF-4BE2-A84A-E1A8BFAA5078),
        dual,
        helpstring("IServiceRequest-Interface"),
        nonextensible,
        pointer_default(unique),
        helpcontext(0)
    ]
    interface IServiceRequest : IDynamicDataEntryBase
    {
        [propget, id(1), helpstring("Eigenschaft Params"), helpcontext(0)]
        HRESULT Params([out, retval] IServiceParamCol** ppVal);
 
    };
 
    [
        uuid(32841B21-4F42-4FCE-93F1-68DBE9963736),
        helpstring("ServiceRequest Class"),
        helpcontext(0)
    ]
    coclass ServiceRequest
    {
        [default] interface IServiceRequest;
        [default, source] dispinterface _IDataEntryBaseEvents;
    };
 
    [
        object,
        uuid(ACC33C0C-BA3C-4002-B175-A4700BFE526D),
        dual,
        helpstring("IServiceRequestCol-Interface"),
        nonextensible,
        pointer_default(unique),
        helpcontext(0)
    ]
    interface IServiceRequestCol : ICol
    {
        [propget, id(DISPID_VALUE), helpstring("Property Item"), helpcontext(0)]
        HRESULT Item([in] VARIANT vIndex, [out, retval] IServiceRequest**);
        [id(2), helpstring("Methode AddStack"), helpcontext(0)]
        HRESULT AddRequest([in] BSTR sName, [out, retval] IServiceRequest**);
    };
 
    [
        uuid(53C46E5C-622C-41CE-9F4F-EB4B156F5B44),
        helpstring("ServiceRequestCol Class"),
        helpcontext(0)
    ]
    coclass ServiceRequestCol
    {
        [default] interface IServiceRequestCol;
    };
 
    [
        object,
        uuid(4988F0C5-64D5-40BB-9E82-23C1A6AF96DA),
        dual,
        helpstring("IServiceResponse-Interface"),
        nonextensible,
        pointer_default(unique),
        helpcontext(0)
    ]
    interface IServiceResponse : IDynamicDataEntryBase
    {
        [propget, id(1), helpstring("Eigenschaft Params"), helpcontext(0)]
        HRESULT Params([out, retval] IServiceParamCol** ppVal);
    };
 
    [
        uuid(2661205D-6EC5-4C6C-BFB2-245876A21449),
        helpstring("ServiceResponse Class"),
        helpcontext(0)
    ]
    coclass ServiceResponse
    {
        [default] interface IServiceResponse;
        [default, source] dispinterface _IDataEntryBaseEvents;
    };
 
    [
        object,
        uuid(D77A033B-2D8E-45B7-9431-584616B4012A),
        dual,
        helpstring("IServiceResponseCol-Interface"),
        nonextensible,
        pointer_default(unique),
        helpcontext(0)
    ]
    interface IServiceResponseCol : ICol
    {
        [propget, id(DISPID_VALUE), helpstring("Property Item"), helpcontext(0)]
        HRESULT Item([in] VARIANT vIndex, [out, retval] IServiceResponse**);
        [id(2), helpstring("Methode AddStack"), helpcontext(0)]
        HRESULT AddResponse([in] BSTR sName, [out, retval] IServiceResponse**);
    };
 
    [
        uuid(6D7A1D04-BACF-470A-ABF0-C8835A640855),
        helpstring("ServiceResponseCol Class"),
        helpcontext(0)
    ]
    coclass ServiceResponseCol
    {
        [default] interface IServiceResponseCol;
    };
   
    [
        object,
        uuid(6627F0B1-876F-49A5-BD32-F4B50B1A2568),
        dual,
        helpstring("IService-Interface"),
        nonextensible,
        pointer_default(unique),
        helpcontext(0)
    ]
    interface IService : IDatabaseItem
    {
        [propget, id(1), helpstring("Eigenschaft Requests"), helpcontext(0)]
        HRESULT Requests([out, retval] IServiceRequestCol** ppVal);
        [propget, id(2), helpstring("Eigenschaft Responses"), helpcontext(0)]
        HRESULT Responses([out, retval] IServiceResponseCol** ppVal);
        [id(12), helpstring("Methode Send"), helpcontext(307)]
        HRESULT Send();
        [propget, id(13), helpcontext(0)]
        HRESULT ErrorCode([out, retval] IAttribute** error);
        [propget, id(14), helpcontext(0)]
        HRESULT LastResponse([out, retval] IAttribute** data);
        [propget, id(4000), helpcontext(404)]  HRESULT TransmissionEvent([out, retval] ITransmissionEvent** ppItem);
 
        [propget, id(4005), helpstring("Eigenschaft PreTransmitEvents"), helpcontext(409)]
        HRESULT PreTransmitEvents([out, retval] VARIANT_BOOL* pVal);
        [propput, id(4005), helpstring("Eigenschaft PreTransmitEvents"), helpcontext(410)]
        HRESULT PreTransmitEvents([in] VARIANT_BOOL boVal);
 
        [propget, id(4006), helpstring("Eigenschaft PreCopyEvents"), helpcontext(411)]
        HRESULT PreCopyEvents([out, retval] VARIANT_BOOL* pVal);
        [propput, id(4006), helpstring("Eigenschaft PreCopyEvents"), helpcontext(412)]
        HRESULT PreCopyEvents([in] VARIANT_BOOL boVal);
    };
 
    [
        uuid(CD1C9ABB-8D9B-4DA2-9798-8EF52199001E),
        helpstring("_IServiceEreignisschnittstelle"),
        helpcontext(0)
    ]
    dispinterface _IServiceEvents
    {
    properties:
    methods:
        [id(10), helpstring("Methode OnPreTransmit - Wird vom COM-Thread aufgerufen."), helpcontext(289)]
        HRESULT OnPreTransmit([in] TransmissionData* pTransmission, [in] BoolValue* pAllowSend);
        [id(11), helpstring("Methode OnPreCopy - Wird vom COM-Thread aufgerufen."), helpcontext(290)]
        HRESULT OnPreCopy([in] TransmissionData* pTransmission, [out] BoolValue* pAllowCopy);
        [id(12), helpstring("Methode OnTxConfirm - Wird vom COM-Thread aufgerufen."), hidden, helpcontext(291)]
        HRESULT OnTxConfirm([in] TransmissionData* pTransmission);
        [id(13), helpstring("Methode OnRxConfirm - Wird vom COM-Thread aufgerufen."), hidden, helpcontext(292)]
        HRESULT OnRxConfirm([in] TransmissionData* pTransmission);
        [id(14), helpcontext(293)]  HRESULT OnTransmission([in] TransmissionData* pTransmission);
        [id(31), helpstring("Methode OnPreTransmitSync - Wird vom Auslöser-Thread aufgerufen."), restricted, hidden, helpcontext(295)]
        HRESULT OnPreTransmitSync([in] TransmissionData* pTransmission, [in] BoolValue* pAllowSend);
        [id(32), helpstring("Methode OnPreCopySync - Wird vom Auslöser-Thread aufgerufen."), restricted, hidden, helpcontext(296)]
        HRESULT OnPreCopySync([in] TransmissionData* pTransmission, [out] BoolValue* pAllowCopy);
        [id(33), helpstring("Methode OnTxConfirmSync - Wird vom Auslöser-Thread aufgerufen."), restricted, hidden, helpcontext(297)]
        HRESULT OnTxConfirmSync([in] TransmissionData* pTransmission);
        [id(34), helpstring("Methode OnRxConfirmSync - Wird vom Auslöser-Thread aufgerufen."), restricted, hidden, helpcontext(298)]
        HRESULT OnRxConfirmSync([in] TransmissionData* pTransmission);
        [id(35), restricted, hidden, helpcontext(299)]  HRESULT OnTransmissionMT([in] TransmissionData* pTransmission);
    };
   
    [
        uuid(E5572532-67D6-44F7-8F3E-380B5B262845),
        helpstring("Service Class"),
        helpcontext(0)
    ]
    coclass Service
    {
        [default] interface IService;
        [default, source] dispinterface _IServiceEvents;
    };
 
    [
        object,
        uuid(916D9BC8-CD0F-4BDC-BFDA-4E4A687F4E08),
        dual,
        helpstring("IServiceCol-Interface"),
        nonextensible,
        pointer_default(unique),
        helpcontext(0)
    ]
    interface IServiceCol : ICol
    {
        [propget, id(DISPID_VALUE), helpstring("Property Item"), helpcontext(0)]
        HRESULT Item([in] VARIANT vIndex, [out, retval] IService** ppService);
        [id(2), helpstring("Methode AddStack"), helpcontext(0)]
        HRESULT AddService([in] BSTR sName, [out, retval] IService**);
    };
 
    [
        uuid(F187869A-191A-436D-B501-2C1117683B04),
        helpstring("ServiceCol Class"),
        helpcontext(0)
    ]
    coclass ServiceCol
    {
        [default] interface IServiceCol;
    };
   
 
    interface IServiceGroupCol;
 
    [
        object,
            uuid(F4FA03A8-67B4-4A48-9DCB-BD937CBC6F62),
            dual,
            helpstring("IServiceGroup-Interface"),
            nonextensible,
            pointer_default(unique),
            helpcontext(0)
    ]
    interface IServiceGroup : IDatabaseItem
    {
        [propget, id(2), helpstring("Eigenschaft Services"), helpcontext(0)]
            HRESULT Services([out, retval] IServiceCol** ppVal);
 
        [propget, id(3), helpstring("Eigenschaft SID"), helpcontext(0)]
            HRESULT SID([out, retval] long* pVal);
    };
 
    [
        uuid(D1FB6334-21A3-42AE-98E1-3F9F8D0B016A),
        helpstring("ServiceGroup Class"),
        helpcontext(0)
    ]
    coclass ServiceGroup
    {
        [default] interface IServiceGroup;
    };
 
    [
        object,
        uuid(90EE32F6-3F1F-4D7D-9ED5-893030641EE1),
        dual,
        helpstring("IServiceGroupCol-Interface"),
        nonextensible,
        pointer_default(unique),
        helpcontext(0)
    ]    
    interface IServiceGroupCol : ICol
    {
        [propget, id(DISPID_VALUE), helpstring("Property Item"), helpcontext(0)]
            HRESULT Item([in] VARIANT vIndex, [out, retval] IServiceGroup**);
        [id(2), helpstring("Methode AddServiceGroup"), helpcontext(0)]
            HRESULT AddServiceGroup([in] BSTR sName, [in] long sid, [out, retval] IServiceGroup**);
    };
 
    [
        uuid(95ECCF97-C95A-4092-B807-2F3EC945D308),
        helpstring("ServiceGroupCol Class"),
        helpcontext(0)
    ]
    coclass ServiceGroupCol
    {
        [default] interface IServiceGroupCol;
    };
 
 
    interface IServiceNamespaceCol;
 
    [
        object,
        uuid(8E42B3C0-1E57-42D1-BCB0-1F8A248F2BE0),
        dual,
        helpstring("IServiceNamespace-Interface"),
        nonextensible,
        pointer_default(unique),
        helpcontext(0)
    ]
    interface IServiceNamespace : IDatabaseItem
    {
        [propget, id(1), helpcontext(0)]
        HRESULT ServiceNamespaces([out, retval] IServiceNamespaceCol** ppVal);
        [propget, id(2), helpcontext(0)]
        HRESULT Services([out, retval] IServiceCol** ppVal);
        [propget, id(3), helpcontext(0)]
        HRESULT ServiceGroups([out, retval] IServiceGroupCol** ppVal);
    };
 
    [
        uuid(FFAC5095-C0E1-4BF1-8AFF-44887C87BB14),
        helpstring("ServiceNamespace Class"),
        helpcontext(0)
    ]
    coclass ServiceNamespace
    {
        [default] interface IServiceNamespace;
    };
 
    [
        object,
        uuid(50C2D56E-8C55-4569-B4F1-3F2DD2EAA0EE),
        dual,
        helpstring("IServiceNamespaceCol-Interface"),
        nonextensible,
        pointer_default(unique),
        helpcontext(0)
    ]
    interface IServiceNamespaceCol : ICol
    {
        [propget, id(DISPID_VALUE), helpstring("Property Item"), helpcontext(0)]
        HRESULT Item([in] VARIANT vIndex, [out, retval] IServiceNamespace**);
        [id(2), helpstring("Methode AddStack"), helpcontext(0)]
        HRESULT AddServiceNamespace([in] BSTR sName, [out, retval] IServiceNamespace**);
    };
 
    [
        uuid(7E89DA11-81F6-4153-89D7-4F4DB783DF7B),
        helpstring("ServiceNamespaceCol Class"),
        helpcontext(0)
    ]
    coclass ServiceNamespaceCol
    {
        [default] interface IServiceNamespaceCol;
    };
 
    [
        object,
        uuid(89294074-D458-4899-BF6A-5E6366E8C558),
        dual,
        helpstring("IStack-Interface"),
        nonextensible,
        pointer_default(unique),
        helpcontext(0)
    ]
    interface IStack : IDatabaseItem
    {
        [propget, id(1), helpstring("Eigenschaft Content"), restricted, hidden, helpcontext(0)]
        HRESULT Content([out, retval] VARIANT *pData);
        [propput, id(1), helpstring("Eigenschaft Content"), restricted, hidden, helpcontext(0)]
        HRESULT Content([in] VARIANT vData);
        [propget, id(2), helpstring("Eigenschaft DefaultSession"), helpcontext(0)]
        HRESULT DefaultSession([out, retval] VARIANT_BOOL *pData);
        [propput, id(2), helpstring("Eigenschaft DefaultSession"), helpcontext(0)]
        HRESULT DefaultSession([in] VARIANT_BOOL vData);
        [propget, id(3), helpstring("Eigenschaft File"), restricted, hidden, helpcontext(0)]
        HRESULT File([out, retval] BSTR *pData);
        [propput, id(3), helpstring("Eigenschaft File"), restricted, hidden, helpcontext(0)]
        HRESULT File([in] BSTR vData);
        [propget, id(4), helpstring("Eigenschaft Overwrite"), restricted, hidden, helpcontext(0)]
        HRESULT Overwrite([out, retval] VARIANT_BOOL *pData);
        [propput, id(4), helpstring("Eigenschaft Overwrite"), restricted, hidden, helpcontext(0)]
        HRESULT Overwrite([in] VARIANT_BOOL vData);
        [propget, id(5), helpstring("Eigenschaft RxId"), helpcontext(0)]
        HRESULT RxId([out, retval] LONG *pData);
        [propput, id(5), helpstring("Eigenschaft RxId"), helpcontext(0)]
        HRESULT RxId([in] LONG vData);
        [propget, id(6), helpstring("Eigenschaft TxId"), helpcontext(0)]
        HRESULT TxId([out, retval] LONG *pData);
        [propput, id(6), helpstring("Eigenschaft TxId"), helpcontext(0)]
        HRESULT TxId([in] LONG vData);
        [propget, id(7), helpstring("Eigenschaft Timeout"), helpcontext(0)]
        HRESULT Timeout([out, retval] LONG *pData);
        [propput, id(7), helpstring("Eigenschaft Timeout"), helpcontext(0)]
        HRESULT Timeout([in] LONG vData);
        [propget, id(8), helpstring("Eigenschaft Namespaces"), helpcontext(0)]
        HRESULT ServiceNamespaces([out, retval] IServiceNamespaceCol** ppVal);
        [propget, id(9), helpstring("Eigenschaft Services"), helpcontext(0)]
        HRESULT Services([out, retval] IServiceCol** ppVal);
 
        [id(10), helpcontext(0)] HRESULT TransmitData([in]VARIANT data);
        [id(11), helpcontext(0)] HRESULT TransmitDataAndWait([in]VARIANT data, [in] long timeout, [out, retval] VARIANT_BOOL*);
        [propget, id(12), helpcontext(0)]
        HRESULT ErrorCode([out, retval] IAttribute** error);
        [propget, id(13), helpcontext(0)]
        HRESULT LastResponse([out, retval] IAttribute** data);
 
        [id(14), helpcontext(0)] HRESULT Disconnect();
        [id(15), helpcontext(0)] HRESULT TransmitDataFunctional([in]VARIANT data);
        [id(16), helpcontext(0)] HRESULT TransmitDataAndWaitFunctional([in]VARIANT data, [in] long timeout, [out, retval] VARIANT_BOOL*);
        [propget, id(4000), helpcontext(404)]  HRESULT TransmissionEvent([out, retval] ITransmissionEvent**);
 
        [id(17), helpcontext(0)] HRESULT Import([in]BSTR file, [in]BSTR variant);
        [id(18), helpcontext(0)] HRESULT SecurityAccess([in]VARIANT key, [out, retval] VARIANT_BOOL*);
        [propget, id(19), helpcontext(0)] HRESULT DTC([out, retval] IDTCContainer**);
        [propget, id(20), helpcontext(0)]
        HRESULT ServiceGroups([out, retval] IServiceGroupCol** ppVal);
    };
 
    [
        uuid(EB8BCBBB-F2E6-4022-84B0-62CA44A7B3A0),
        helpcontext(0)
    ]
    dispinterface _IStackEvents
    {
    properties:
    methods:
        [id(1), helpcontext(0)]  HRESULT OnTransmission([in] TransmissionData* pTransmission);
    };
 
    [
        uuid(F83A60B0-1083-45F8-B99B-B4B6D8B20BF7),
        helpstring("Stack Class"),
        helpcontext(0)
    ]
    coclass Stack
    {
        [default] interface IStack;
        [default, source] dispinterface _IStackEvents;
    }; 
 
    [
        object,
        uuid(96EE2F1D-45BD-487D-9018-BCCD09E1B04C),
        dual,
        helpstring("IStackCol-Interface"),
        nonextensible,
        pointer_default(unique),
        helpcontext(0)
    ]
    interface IStackCol : ICol
    {
        [propget, id(DISPID_VALUE), helpstring("Property Item"), helpcontext(0)]
        HRESULT Item([in] VARIANT vIndex, [out, retval] IStack**);
        [id(2), helpstring("Methode AddStack"), helpcontext(0)]
        HRESULT AddStack([in] BSTR sName, [out, retval] IStack**);
    };
 
    [
        uuid(1868196B-E152-4845-9176-31B271DD58F8),
        helpstring("StackCol Class"),
        helpcontext(0)
    ]
    coclass StackCol
    {
        [default] interface IStackCol;
    };
 
 
    [
        object,
        uuid(259DDD00-1399-4C0B-9E22-EE947988E1F8),
        dual,
        helpstring("IDiagServiceRecordEntry-Schnittstelle"),
        pointer_default(unique),
        hidden,
        helpcontext(0)
    ]
    interface IDiagServiceRecordEntry : IBusRecordEntry
    {
        [propget, id(23), helpstring("Eigenschaft SID"), helpcontext(0)]
        HRESULT SID([out, retval] byte* sid);
        [id(24), helpstring("IsRequest"), helpcontext(0)]
        HRESULT IsRequest([out, retval] VARIANT_BOOL* pVal);
        [id(25), helpstring("IsResponse"), helpcontext(0)]
        HRESULT IsResponse([out, retval] VARIANT_BOOL* pVal);
        [id(26), helpstring("IsNegativeResponse"), helpcontext(0)]
        HRESULT IsNegativeResponse([out, retval] VARIANT_BOOL* pVal);
        [propget, id(28), helpstring("Eigenschaft Length"), helpcontext(641)]
        HRESULT Length([out, retval] long* pLength);
        [propget, id(29), helpstring("Eigenschaft Data"), helpcontext(642)]
        HRESULT Data([out, retval] VARIANT* pData);
    };
 
    [
        uuid(4546A446-98CE-4F12-80F5-F047D3BA986B),
        helpstring("DiagServiceRecordEntry Class"),
        helpcontext(0)
    ]
    coclass DiagServiceRecordEntry
    {
        [default] interface IDiagServiceRecordEntry;
    };
 
    [
        uuid(12B52AD7-5C8F-4D76-A548-725CEC784E73),
        dual,
        helpstring("ITestReport-Interface"),
        nonextensible,
        pointer_default(unique),
        helpcontext(0)
    ]
    interface ITestReport : IDispatch
    {
        [id(1), helpcontext(0)]
        HRESULT AddEngineerInfo([in] BSTR name, [in] BSTR description);
        [id(2), helpcontext(0)]
        HRESULT AddSetupInfo([in] BSTR name, [in] BSTR description);
        [id(3), helpcontext(0)]
        HRESULT AddSUTInfo([in] BSTR name, [in] BSTR description);
        [id(4), helpcontext(0)]
        HRESULT AddMiscInfo([in] BSTR name, [in] BSTR description);
        [propget, id(5), helpcontext(0)]
        HRESULT Title([out, retval] BSTR* name);
        [propput, id(5), helpcontext(0)]
        HRESULT Title([in] BSTR name);
        [propget, id(6), helpcontext(0)]
        HRESULT Description([out, retval] BSTR* desc);
        [propput, id(6), helpcontext(0)]
        HRESULT Description([in] BSTR desc);
        [propget, id(7), helpcontext(0)]
        HRESULT Filename([out, retval] BSTR* file);
        [propput, id(7), helpcontext(0)]
        HRESULT Filename([in] BSTR file);
        [id(8), helpcontext(0)]
        HRESULT Comment([in] BSTR comment);
        [id(9), helpcontext(0)]
        HRESULT Step([in] BSTR identifier, [in] BSTR desc, [in, optional] VARIANT level);
        [id(10), helpcontext(0)]
        HRESULT StepPass([in] BSTR identifier, [in] BSTR desc, [in, optional] VARIANT level);
        [id(11), helpcontext(0)]
        HRESULT StepFail([in] BSTR identifier, [in] BSTR desc, [in, optional] VARIANT level);
        [id(12), helpcontext(0)]
        HRESULT StepWarning([in] BSTR identifier, [in] BSTR desc, [in, optional] VARIANT level);
        [id(13), helpcontext(0)]
        HRESULT StepInconclusive([in] BSTR identifier, [in] BSTR desc, [in, optional] VARIANT level);
        [id(14), helpcontext(0)]
        HRESULT StepErrorInTestSystem([in] BSTR identifier, [in] BSTR desc, [in, optional] VARIANT level);
        [id(15), helpcontext(0)]
        HRESULT OpenTestcase([in] BSTR name, [in] BSTR desc, [in] BSTR identifier);
        [id(16), helpcontext(0)]
        HRESULT OpenPattern([in] BSTR name, [in] BSTR desc, [in] BSTR identifier);
        [id(17), helpcontext(0)]
        HRESULT OpenGroup([in] BSTR name, [in] BSTR desc, [in] BSTR identifier);
        [id(18), helpcontext(0)]
        HRESULT SetGroupTitle([in] BSTR identifier, [in] BSTR name);
        [propget, id(19), helpcontext(0)]
        HRESULT GroupLevel([out, retval] long* level);
        [id(20), helpcontext(0)]
        HRESULT CloseTestcase();
        [id(21), helpcontext(0)]
        HRESULT ClosePattern();
        [id(22), helpcontext(0)]
        HRESULT CloseGroup();
        [id(23), helpcontext(0)]
        HRESULT StartTestReport([in] BSTR outDir, [in] BSTR name);
        [id(24), helpcontext(0)]
        HRESULT CloseTestReport();
    };
 
    [
        uuid(3BEFC9BC-658E-42F3-8BF4-7E6E85C44521),
        helpstring("TestReport Class"),
        helpcontext(0)
    ]
    coclass TestReport
    {
        [default] interface ITestReport;
    };
 // end of Classes_CanEasyCOM
};