From 06b02acf9c794cf410ff514827f9fd029a720435 Mon Sep 17 00:00:00 2001 From: Unity Technologies <@unity> Date: Fri, 9 Apr 2021 00:00:00 +0000 Subject: [PATCH] com.unity.ide.visualstudio@2.0.8 ## [2.0.8] - 2021-04-09 Project generation: Improved generation performance (especially with DOTS enabled projects). Improved stability. Updated Analyzers lookup strategy. Fixed .vsconfig file not generated when using "regenerate all". Integration Improved automation plugins. Documentation Open sourced automation plugins. --- CHANGELOG.md | 20 +- .../project.pbxproj | 308 + .../AppleEventIntegration/Info.plist | 26 + .../AppleEventIntegration/main.mm | 291 + .../COMIntegration~/BStrHolder.h | 40 + .../COMIntegration~/BStrHolder.h.meta | 26 + .../COMIntegration~/CMakeLists.txt | 13 + .../COMIntegration~/CMakeLists.txt.meta | 7 + .../COMIntegration~/COMIntegration.cpp | 468 + .../COMIntegration~/COMIntegration.cpp.meta | 27 + .../COMIntegration/COMIntegration~/ComPtr.h | 186 + .../COMIntegration~/ComPtr.h.meta | 26 + .../COMIntegration/COMIntegration~/dte80a.tlh | 7538 +++++++++++++++++ .../COMIntegration~/dte80a.tlh.meta | 7 + .../COMIntegration~/release-build.txt | 1 + .../COMIntegration~/release-build.txt.meta | 7 + .../COMIntegration/Release/COMIntegration.exe | Bin 261120 -> 258560 bytes .../ProjectGeneration/AssemblyNameProvider.cs | 101 +- Editor/ProjectGeneration/ProjectGeneration.cs | 25 +- Editor/VisualStudioEditor.cs | 2 +- Editor/VisualStudioInstallation.cs | 81 +- package.json | 12 +- 22 files changed, 9125 insertions(+), 87 deletions(-) create mode 100644 Editor/AppleEventIntegration~/AppleEventIntegration.xcodeproj/project.pbxproj create mode 100644 Editor/AppleEventIntegration~/AppleEventIntegration/Info.plist create mode 100644 Editor/AppleEventIntegration~/AppleEventIntegration/main.mm create mode 100644 Editor/COMIntegration/COMIntegration~/BStrHolder.h create mode 100644 Editor/COMIntegration/COMIntegration~/BStrHolder.h.meta create mode 100644 Editor/COMIntegration/COMIntegration~/CMakeLists.txt create mode 100644 Editor/COMIntegration/COMIntegration~/CMakeLists.txt.meta create mode 100644 Editor/COMIntegration/COMIntegration~/COMIntegration.cpp create mode 100644 Editor/COMIntegration/COMIntegration~/COMIntegration.cpp.meta create mode 100644 Editor/COMIntegration/COMIntegration~/ComPtr.h create mode 100644 Editor/COMIntegration/COMIntegration~/ComPtr.h.meta create mode 100644 Editor/COMIntegration/COMIntegration~/dte80a.tlh create mode 100644 Editor/COMIntegration/COMIntegration~/dte80a.tlh.meta create mode 100644 Editor/COMIntegration/COMIntegration~/release-build.txt create mode 100644 Editor/COMIntegration/COMIntegration~/release-build.txt.meta diff --git a/CHANGELOG.md b/CHANGELOG.md index a75f41a..15701ec 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,10 +1,28 @@ # Code Editor Package for Visual Studio +## [2.0.8] - 2021-04-09 + +Project generation: + +Improved generation performance (especially with DOTS enabled projects). +Improved stability. +Updated Analyzers lookup strategy. +Fixed .vsconfig file not generated when using "regenerate all". + +Integration + +Improved automation plugins. + +Documentation + +Open sourced automation plugins. + + ## [2.0.7] - 2021-02-02 Integration: -Remove com.unity.nuget.newtonsoft-json dependency in favor of the built-in JsonUtility for the VS Test Runner. +- Remove com.unity.nuget.newtonsoft-json dependency in favor of the built-in JsonUtility for the VS Test Runner. ## [2.0.6] - 2021-01-20 diff --git a/Editor/AppleEventIntegration~/AppleEventIntegration.xcodeproj/project.pbxproj b/Editor/AppleEventIntegration~/AppleEventIntegration.xcodeproj/project.pbxproj new file mode 100644 index 0000000..b710309 --- /dev/null +++ b/Editor/AppleEventIntegration~/AppleEventIntegration.xcodeproj/project.pbxproj @@ -0,0 +1,308 @@ +// !$*UTF8*$! +{ + archiveVersion = 1; + classes = { + }; + objectVersion = 50; + objects = { + +/* Begin PBXBuildFile section */ + E08E02FF236392D000A4B1BE /* main.mm in Sources */ = {isa = PBXBuildFile; fileRef = E08E02FE236392D000A4B1BE /* main.mm */; }; + E08E03022363933B00A4B1BE /* AppKit.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = E08E03012363933B00A4B1BE /* AppKit.framework */; }; +/* End PBXBuildFile section */ + +/* Begin PBXFileReference section */ + E08E02F5236392A300A4B1BE /* AppleEventIntegration.bundle */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = AppleEventIntegration.bundle; sourceTree = BUILT_PRODUCTS_DIR; }; + E08E02F8236392A300A4B1BE /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = ""; }; + E08E02FE236392D000A4B1BE /* main.mm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.objcpp; path = main.mm; sourceTree = ""; }; + E08E03012363933B00A4B1BE /* AppKit.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = AppKit.framework; path = System/Library/Frameworks/AppKit.framework; sourceTree = SDKROOT; }; +/* End PBXFileReference section */ + +/* Begin PBXFrameworksBuildPhase section */ + E08E02F2236392A300A4B1BE /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + E08E03022363933B00A4B1BE /* AppKit.framework in Frameworks */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXFrameworksBuildPhase section */ + +/* Begin PBXGroup section */ + E08E02EC236392A300A4B1BE = { + isa = PBXGroup; + children = ( + E08E02F7236392A300A4B1BE /* AppleEventIntegration */, + E08E02F6236392A300A4B1BE /* Products */, + E08E03002363933B00A4B1BE /* Frameworks */, + ); + sourceTree = ""; + }; + E08E02F6236392A300A4B1BE /* Products */ = { + isa = PBXGroup; + children = ( + E08E02F5236392A300A4B1BE /* AppleEventIntegration.bundle */, + ); + name = Products; + sourceTree = ""; + }; + E08E02F7236392A300A4B1BE /* AppleEventIntegration */ = { + isa = PBXGroup; + children = ( + E08E02F8236392A300A4B1BE /* Info.plist */, + E08E02FE236392D000A4B1BE /* main.mm */, + ); + path = AppleEventIntegration; + sourceTree = ""; + }; + E08E03002363933B00A4B1BE /* Frameworks */ = { + isa = PBXGroup; + children = ( + E08E03012363933B00A4B1BE /* AppKit.framework */, + ); + name = Frameworks; + sourceTree = ""; + }; +/* End PBXGroup section */ + +/* Begin PBXNativeTarget section */ + E08E02F4236392A300A4B1BE /* AppleEventIntegration */ = { + isa = PBXNativeTarget; + buildConfigurationList = E08E02FB236392A300A4B1BE /* Build configuration list for PBXNativeTarget "AppleEventIntegration" */; + buildPhases = ( + E08E02F1236392A300A4B1BE /* Sources */, + E08E02F2236392A300A4B1BE /* Frameworks */, + E08E02F3236392A300A4B1BE /* Resources */, + ); + buildRules = ( + ); + dependencies = ( + ); + name = AppleEventIntegration; + productName = AppleEventIntegration; + productReference = E08E02F5236392A300A4B1BE /* AppleEventIntegration.bundle */; + productType = "com.apple.product-type.bundle"; + }; +/* End PBXNativeTarget section */ + +/* Begin PBXProject section */ + E08E02ED236392A300A4B1BE /* Project object */ = { + isa = PBXProject; + attributes = { + LastUpgradeCheck = 1200; + ORGANIZATIONNAME = Unity; + TargetAttributes = { + E08E02F4236392A300A4B1BE = { + CreatedOnToolsVersion = 11.1; + }; + }; + }; + buildConfigurationList = E08E02F0236392A300A4B1BE /* Build configuration list for PBXProject "AppleEventIntegration" */; + compatibilityVersion = "Xcode 9.3"; + developmentRegion = en; + hasScannedForEncodings = 0; + knownRegions = ( + en, + Base, + ); + mainGroup = E08E02EC236392A300A4B1BE; + productRefGroup = E08E02F6236392A300A4B1BE /* Products */; + projectDirPath = ""; + projectRoot = ""; + targets = ( + E08E02F4236392A300A4B1BE /* AppleEventIntegration */, + ); + }; +/* End PBXProject section */ + +/* Begin PBXResourcesBuildPhase section */ + E08E02F3236392A300A4B1BE /* Resources */ = { + isa = PBXResourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXResourcesBuildPhase section */ + +/* Begin PBXSourcesBuildPhase section */ + E08E02F1236392A300A4B1BE /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + E08E02FF236392D000A4B1BE /* main.mm in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXSourcesBuildPhase section */ + +/* Begin XCBuildConfiguration section */ + E08E02F9236392A300A4B1BE /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + CLANG_ANALYZER_NONNULL = YES; + CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++14"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_ENABLE_MODULES = YES; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_ENABLE_OBJC_WEAK = YES; + CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_COMMA = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_DOCUMENTATION_COMMENTS = YES; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INFINITE_RECURSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES; + CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES; + CLANG_WARN_OBJC_LITERAL_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN_QUOTED_INCLUDE_IN_FRAMEWORK_HEADER = YES; + CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; + CLANG_WARN_STRICT_PROTOTYPES = YES; + CLANG_WARN_SUSPICIOUS_MOVE = YES; + CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE; + CLANG_WARN_UNREACHABLE_CODE = YES; + CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; + COPY_PHASE_STRIP = NO; + DEBUG_INFORMATION_FORMAT = dwarf; + ENABLE_STRICT_OBJC_MSGSEND = YES; + ENABLE_TESTABILITY = YES; + GCC_C_LANGUAGE_STANDARD = gnu11; + GCC_DYNAMIC_NO_PIC = NO; + GCC_NO_COMMON_BLOCKS = YES; + GCC_OPTIMIZATION_LEVEL = 0; + GCC_PREPROCESSOR_DEFINITIONS = ( + "DEBUG=1", + "$(inherited)", + ); + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNDECLARED_SELECTOR = YES; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + MACOSX_DEPLOYMENT_TARGET = 10.13; + MTL_ENABLE_DEBUG_INFO = INCLUDE_SOURCE; + MTL_FAST_MATH = YES; + ONLY_ACTIVE_ARCH = YES; + SDKROOT = macosx; + }; + name = Debug; + }; + E08E02FA236392A300A4B1BE /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + CLANG_ANALYZER_NONNULL = YES; + CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++14"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_ENABLE_MODULES = YES; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_ENABLE_OBJC_WEAK = YES; + CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_COMMA = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_DOCUMENTATION_COMMENTS = YES; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INFINITE_RECURSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES; + CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES; + CLANG_WARN_OBJC_LITERAL_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN_QUOTED_INCLUDE_IN_FRAMEWORK_HEADER = YES; + CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; + CLANG_WARN_STRICT_PROTOTYPES = YES; + CLANG_WARN_SUSPICIOUS_MOVE = YES; + CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE; + CLANG_WARN_UNREACHABLE_CODE = YES; + CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; + COPY_PHASE_STRIP = NO; + DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; + ENABLE_NS_ASSERTIONS = NO; + ENABLE_STRICT_OBJC_MSGSEND = YES; + GCC_C_LANGUAGE_STANDARD = gnu11; + GCC_NO_COMMON_BLOCKS = YES; + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNDECLARED_SELECTOR = YES; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + MACOSX_DEPLOYMENT_TARGET = 10.13; + MTL_ENABLE_DEBUG_INFO = NO; + MTL_FAST_MATH = YES; + SDKROOT = macosx; + }; + name = Release; + }; + E08E02FC236392A300A4B1BE /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + CODE_SIGN_STYLE = Automatic; + COMBINE_HIDPI_IMAGES = YES; + DEVELOPMENT_TEAM = ""; + INFOPLIST_FILE = AppleEventIntegration/Info.plist; + INSTALL_PATH = "$(LOCAL_LIBRARY_DIR)/Bundles"; + MACOSX_DEPLOYMENT_TARGET = 10.13; + PRODUCT_BUNDLE_IDENTIFIER = com.unity.visualstudio.AppleEventIntegration; + PRODUCT_NAME = "$(TARGET_NAME)"; + SKIP_INSTALL = YES; + WRAPPER_EXTENSION = bundle; + }; + name = Debug; + }; + E08E02FD236392A300A4B1BE /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + CODE_SIGN_STYLE = Automatic; + COMBINE_HIDPI_IMAGES = YES; + DEVELOPMENT_TEAM = ""; + INFOPLIST_FILE = AppleEventIntegration/Info.plist; + INSTALL_PATH = "$(LOCAL_LIBRARY_DIR)/Bundles"; + MACOSX_DEPLOYMENT_TARGET = 10.13; + PRODUCT_BUNDLE_IDENTIFIER = com.unity.visualstudio.AppleEventIntegration; + PRODUCT_NAME = "$(TARGET_NAME)"; + SKIP_INSTALL = YES; + WRAPPER_EXTENSION = bundle; + }; + name = Release; + }; +/* End XCBuildConfiguration section */ + +/* Begin XCConfigurationList section */ + E08E02F0236392A300A4B1BE /* Build configuration list for PBXProject "AppleEventIntegration" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + E08E02F9236392A300A4B1BE /* Debug */, + E08E02FA236392A300A4B1BE /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + E08E02FB236392A300A4B1BE /* Build configuration list for PBXNativeTarget "AppleEventIntegration" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + E08E02FC236392A300A4B1BE /* Debug */, + E08E02FD236392A300A4B1BE /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; +/* End XCConfigurationList section */ + }; + rootObject = E08E02ED236392A300A4B1BE /* Project object */; +} diff --git a/Editor/AppleEventIntegration~/AppleEventIntegration/Info.plist b/Editor/AppleEventIntegration~/AppleEventIntegration/Info.plist new file mode 100644 index 0000000..225df23 --- /dev/null +++ b/Editor/AppleEventIntegration~/AppleEventIntegration/Info.plist @@ -0,0 +1,26 @@ + + + + + CFBundleDevelopmentRegion + $(DEVELOPMENT_LANGUAGE) + CFBundleExecutable + $(EXECUTABLE_NAME) + CFBundleIdentifier + $(PRODUCT_BUNDLE_IDENTIFIER) + CFBundleInfoDictionaryVersion + 6.0 + CFBundleName + $(PRODUCT_NAME) + CFBundlePackageType + $(PRODUCT_BUNDLE_PACKAGE_TYPE) + CFBundleShortVersionString + 1.0 + CFBundleVersion + 1 + NSHumanReadableCopyright + Copyright © 2019 Unity. All rights reserved. + NSPrincipalClass + + + diff --git a/Editor/AppleEventIntegration~/AppleEventIntegration/main.mm b/Editor/AppleEventIntegration~/AppleEventIntegration/main.mm new file mode 100644 index 0000000..a53cf84 --- /dev/null +++ b/Editor/AppleEventIntegration~/AppleEventIntegration/main.mm @@ -0,0 +1,291 @@ +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Unity Technologies. + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +#import +#import + +// 'FSnd' FourCC +#define keyFileSender 1179872868 + +// 16 bit aligned legacy struct - this should total 20 bytes +struct SelectionRange +{ + int16_t unused1; // 0 (not used) + int16_t lineNum; // line to select (<0 to specify range) + int32_t startRange; // start of selection range (if line < 0) + int32_t endRange; // end of selection range (if line < 0) + int32_t unused2; // 0 (not used) + int32_t theDate; // modification date/time +} __attribute__((packed)); + +static NSString* MakeNSString(const char* str) +{ + if (!str) + return NULL; + + NSString* ret = [NSString stringWithUTF8String: str]; + return ret; +} + +static UInt32 GetCreatorOfThisApp() +{ + static UInt32 creator = 0; + if (creator == 0) + { + UInt32 type; + CFBundleGetPackageInfo(CFBundleGetMainBundle(), &type, &creator); + } + return creator; +} + +static BOOL OpenFileAtLineWithAppleEvent(NSRunningApplication *runningApp, NSString* path, int line) +{ + if (!runningApp) + return NO; + + NSURL *pathUrl = [NSURL fileURLWithPath: path]; + + NSAppleEventDescriptor* targetDescriptor = [NSAppleEventDescriptor + descriptorWithProcessIdentifier: runningApp.processIdentifier]; + + NSAppleEventDescriptor* appleEvent = [NSAppleEventDescriptor + appleEventWithEventClass: kCoreEventClass + eventID: kAEOpenDocuments + targetDescriptor: targetDescriptor + returnID: kAutoGenerateReturnID + transactionID: kAnyTransactionID]; + + [appleEvent + setParamDescriptor: [NSAppleEventDescriptor + descriptorWithDescriptorType: typeFileURL + data: [[pathUrl absoluteString] dataUsingEncoding: NSUTF8StringEncoding]] + forKeyword: keyDirectObject]; + + UInt32 packageCreator = GetCreatorOfThisApp(); + if (packageCreator == kUnknownType) { + [appleEvent + setParamDescriptor: [NSAppleEventDescriptor + descriptorWithDescriptorType: typeApplicationBundleID + data: [[[NSBundle mainBundle] bundleIdentifier] dataUsingEncoding: NSUTF8StringEncoding]] + forKeyword: keyFileSender]; + } else { + [appleEvent + setParamDescriptor: [NSAppleEventDescriptor descriptorWithTypeCode: packageCreator] + forKeyword: keyFileSender]; + } + + if (line != -1) { + // Add selection range to event + SelectionRange range; + range.unused1 = 0; + range.lineNum = line - 1; + range.startRange = -1; + range.endRange = -1; + range.unused2 = 0; + range.theDate = -1; + + [appleEvent + setParamDescriptor: [NSAppleEventDescriptor + descriptorWithDescriptorType: typeChar + bytes: &range + length: sizeof(SelectionRange)] + forKeyword: keyAEPosition]; + } + + AEDesc reply = { typeNull, NULL }; + OSErr err = AESendMessage( + [appleEvent aeDesc], + &reply, + kAENoReply + kAENeverInteract, + kAEDefaultTimeout); + + return err == noErr; +} + +static BOOL ApplicationSupportsQueryOpenedSolution(NSString* appPath) +{ + NSURL* appUrl = [NSURL fileURLWithPath: appPath]; + NSBundle* bundle = [NSBundle bundleWithURL: appUrl]; + + if (!bundle) + return NO; + + id versionValue = [bundle objectForInfoDictionaryKey: @"CFBundleVersion"]; + if (!versionValue || ![versionValue isKindOfClass: [NSString class]]) + return NO; + + NSString* version = (NSString*)versionValue; + NSArray* components = [version componentsSeparatedByString:@"."]; + if (!components || components.count < 2) + return NO; + + return [components[0] integerValue] >= 8 + && [components[1] integerValue] >= 6; +} + +static NSArray* QueryRunningInstances(NSString *appPath) +{ + NSMutableArray* instances = [[NSMutableArray alloc] init]; + NSURL *appUrl = [NSURL fileURLWithPath: appPath]; + + for (NSRunningApplication *runningApp in NSWorkspace.sharedWorkspace.runningApplications) { + if (![runningApp isTerminated] && [runningApp.bundleURL isEqual: appUrl]) { + [instances addObject: runningApp]; + } + } + + return instances; +} + +enum { + kWorkspaceEventClass = 1448302419, /* 'VSWS' FourCC */ + kCurrentSelectedSolutionPathEventID = 1129534288 /* 'CSSP' FourCC */ +}; + +static BOOL TryQueryCurrentSolutionPath(NSRunningApplication* runningApp, NSString** solutionPath) +{ + NSAppleEventDescriptor* targetDescriptor = [NSAppleEventDescriptor + descriptorWithProcessIdentifier: runningApp.processIdentifier]; + + NSAppleEventDescriptor* appleEvent = [NSAppleEventDescriptor + appleEventWithEventClass: kWorkspaceEventClass + eventID: kCurrentSelectedSolutionPathEventID + targetDescriptor: targetDescriptor + returnID: kAutoGenerateReturnID + transactionID: kAnyTransactionID]; + + AEDesc aeReply = { 0, }; + + OSErr sendResult = AESendMessage( + [appleEvent aeDesc], + &aeReply, + kAEWaitReply | kAENeverInteract, + kAEDefaultTimeout); + + if (sendResult != noErr) { + return NO; + } + + NSAppleEventDescriptor *reply = [[NSAppleEventDescriptor alloc] initWithAEDescNoCopy: &aeReply]; + *solutionPath = [[reply descriptorForKeyword: keyDirectObject] stringValue]; + + return *solutionPath != NULL; +} + +static NSRunningApplication* QueryRunningApplicationOpenedOnSolution(NSString* appPath, NSString* solutionPath) +{ + BOOL supportsQueryOpenedSolution = ApplicationSupportsQueryOpenedSolution(appPath); + + for (NSRunningApplication *runningApp in QueryRunningInstances(appPath)) { + // If the currently selected external editor does not support the opened solution apple event + // then fallback to the previous behavior: take the first opened VSM and open the solution + if (!supportsQueryOpenedSolution) { + OpenFileAtLineWithAppleEvent(runningApp, solutionPath, -1); + return runningApp; + } + + NSString* currentSolutionPath; + if (TryQueryCurrentSolutionPath(runningApp, ¤tSolutionPath)) { + if ([solutionPath isEqual:currentSolutionPath]) { + return runningApp; + } + } else { + // If VSM doesn't respond to the query opened solution event + // we fallback to the previous behavior too + OpenFileAtLineWithAppleEvent(runningApp, solutionPath, -1); + return runningApp; + } + } + + return NULL; +} + +static NSRunningApplication* LaunchApplicationOnSolution(NSString* appPath, NSString* solutionPath) +{ + NSURL* appUrl = [NSURL fileURLWithPath: appPath]; + NSMutableDictionary* config = [[NSMutableDictionary alloc] init]; + + NSRunningApplication* runningApp = [[NSWorkspace sharedWorkspace] + launchApplicationAtURL: appUrl + options: NSWorkspaceLaunchDefault | NSWorkspaceLaunchNewInstance + configuration: config + error: nil]; + + OpenFileAtLineWithAppleEvent(runningApp, solutionPath, -1); + + return runningApp; +} + +static NSRunningApplication* QueryOrLaunchApplication(NSString* appPath, NSString* solutionPath) +{ + NSRunningApplication* runningApp = QueryRunningApplicationOpenedOnSolution(appPath, solutionPath); + + if (!runningApp) + runningApp = LaunchApplicationOnSolution(appPath, solutionPath); + + if (runningApp) + [runningApp activateWithOptions: 0]; + + return runningApp; +} + +BOOL LaunchOrReuseApp(NSString* appPath, NSString* solutionPath, NSRunningApplication** outApp) +{ + NSRunningApplication* app = QueryOrLaunchApplication(appPath, solutionPath); + + if (outApp) + *outApp = app; + + return app != NULL; +} + +BOOL MonoDevelopOpenFile(NSString* appPath, NSString* solutionPath, NSString* filePath, int line) +{ + NSRunningApplication* runningApp; + if (!LaunchOrReuseApp(appPath, solutionPath, &runningApp)) { + return FALSE; + } + + if (filePath) { + return OpenFileAtLineWithAppleEvent(runningApp, filePath, line); + } + + return YES; +} + +#if BUILD_APP + +int main(int argc, const char** argv) +{ + if (argc != 5) { + printf("Usage: AppleEventIntegration appPath solutionPath filePath lineNumber\n"); + return 1; + } + + const char* appPath = argv[1]; + const char* solutionPath = argv[2]; + const char* filePath = argv[3]; + const int lineNumber = atoi(argv[4]); + + @autoreleasepool + { + MonoDevelopOpenFile(MakeNSString(appPath), MakeNSString(solutionPath), MakeNSString(filePath), lineNumber); + } + + return 0; +} + +#else + +extern "C" +{ + BOOL OpenVisualStudio(const char* appPath, const char* solutionPath, const char* filePath, int line) + { + return MonoDevelopOpenFile(MakeNSString(appPath), MakeNSString(solutionPath), MakeNSString(filePath), line); + } +} + +#endif diff --git a/Editor/COMIntegration/COMIntegration~/BStrHolder.h b/Editor/COMIntegration/COMIntegration~/BStrHolder.h new file mode 100644 index 0000000..91ab224 --- /dev/null +++ b/Editor/COMIntegration/COMIntegration~/BStrHolder.h @@ -0,0 +1,40 @@ +#pragma once +#include + +struct BStrHolder +{ + BStrHolder() : + m_Str(NULL) + { + } + + BStrHolder(const wchar_t* str) : + m_Str(SysAllocString(str)) + { + } + + ~BStrHolder() + { + if (m_Str != NULL) + SysFreeString(m_Str); + } + + operator BSTR() const + { + return m_Str; + } + + BSTR* operator&() + { + if (m_Str != NULL) + { + SysFreeString(m_Str); + m_Str = NULL; + } + + return &m_Str; + } + +private: + BSTR m_Str; +}; diff --git a/Editor/COMIntegration/COMIntegration~/BStrHolder.h.meta b/Editor/COMIntegration/COMIntegration~/BStrHolder.h.meta new file mode 100644 index 0000000..09b789f --- /dev/null +++ b/Editor/COMIntegration/COMIntegration~/BStrHolder.h.meta @@ -0,0 +1,26 @@ +fileFormatVersion: 2 +guid: 1f68874d6ae00db4a993b9507d065658 +PluginImporter: + externalObjects: {} + serializedVersion: 2 + iconMap: {} + executionOrder: {} + defineConstraints: [] + isPreloaded: 0 + isOverridable: 1 + isExplicitlyReferenced: 0 + platformData: + - first: + Any: + second: + enabled: 1 + settings: {} + - first: + Editor: Editor + second: + enabled: 0 + settings: + DefaultValueInitialized: true + userData: + assetBundleName: + assetBundleVariant: diff --git a/Editor/COMIntegration/COMIntegration~/CMakeLists.txt b/Editor/COMIntegration/COMIntegration~/CMakeLists.txt new file mode 100644 index 0000000..f47ccdb --- /dev/null +++ b/Editor/COMIntegration/COMIntegration~/CMakeLists.txt @@ -0,0 +1,13 @@ +cmake_minimum_required(VERSION 3.13) + +project(com) +set(SOURCES + COMIntegration.cpp + BStrHolder.h + ComPtr.h + dte80a.tlh + ) +set(CMAKE_CXX_STANDARD 17) +set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3 -Wall") +add_executable(COMIntegration ${SOURCES}) +target_link_libraries(COMIntegration Shlwapi.lib) diff --git a/Editor/COMIntegration/COMIntegration~/CMakeLists.txt.meta b/Editor/COMIntegration/COMIntegration~/CMakeLists.txt.meta new file mode 100644 index 0000000..1d12d0b --- /dev/null +++ b/Editor/COMIntegration/COMIntegration~/CMakeLists.txt.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: 7cec3e1820a40be4486946c20d7ffd00 +TextScriptImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Editor/COMIntegration/COMIntegration~/COMIntegration.cpp b/Editor/COMIntegration/COMIntegration~/COMIntegration.cpp new file mode 100644 index 0000000..9c48032 --- /dev/null +++ b/Editor/COMIntegration/COMIntegration~/COMIntegration.cpp @@ -0,0 +1,468 @@ +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Unity Technologies. + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +#include +#include +#include +#include +#include +#include + +#include "BStrHolder.h" +#include "ComPtr.h" +#include "dte80a.tlh" + +constexpr int RETRY_INTERVAL_MS = 150; +constexpr int TIMEOUT_MS = 10000; + +// Often a DTE call made to Visual Studio can fail after Visual Studio has just started. Usually the +// return value will be RPC_E_CALL_REJECTED, meaning that Visual Studio is probably busy on another +// thread. This types filter the RPC messages and retries to send the message until VS accepts it. +class CRetryMessageFilter : public IMessageFilter +{ +private: + static bool ShouldRetryCall(DWORD dwTickCount, DWORD dwRejectType) + { + if (dwRejectType == SERVERCALL_RETRYLATER || dwRejectType == SERVERCALL_REJECTED) { + return dwTickCount < TIMEOUT_MS; + } + + return false; + } + + win::ComPtr currentFilter; + +public: + CRetryMessageFilter() + { + HRESULT hr = CoRegisterMessageFilter(this, ¤tFilter); + _ASSERT(SUCCEEDED(hr)); + } + + ~CRetryMessageFilter() + { + win::ComPtr messageFilter; + HRESULT hr = CoRegisterMessageFilter(currentFilter, &messageFilter); + _ASSERT(SUCCEEDED(hr)); + } + + // IUnknown methods + IFACEMETHODIMP QueryInterface(REFIID riid, void** ppv) + { + static const QITAB qit[] = + { + QITABENT(CRetryMessageFilter, IMessageFilter), + { 0 }, + }; + return QISearch(this, qit, riid, ppv); + } + + IFACEMETHODIMP_(ULONG) AddRef() + { + return 0; + } + + IFACEMETHODIMP_(ULONG) Release() + { + return 0; + } + + DWORD STDMETHODCALLTYPE HandleInComingCall(DWORD dwCallType, HTASK htaskCaller, DWORD dwTickCount, LPINTERFACEINFO lpInterfaceInfo) + { + if (currentFilter) + return currentFilter->HandleInComingCall(dwCallType, htaskCaller, dwTickCount, lpInterfaceInfo); + + return SERVERCALL_ISHANDLED; + } + + DWORD STDMETHODCALLTYPE RetryRejectedCall(HTASK htaskCallee, DWORD dwTickCount, DWORD dwRejectType) + { + if (ShouldRetryCall(dwTickCount, dwRejectType)) + return RETRY_INTERVAL_MS; + + if (currentFilter) + return currentFilter->RetryRejectedCall(htaskCallee, dwTickCount, dwRejectType); + + return (DWORD)-1; + } + + DWORD STDMETHODCALLTYPE MessagePending(HTASK htaskCallee, DWORD dwTickCount, DWORD dwPendingType) + { + if (currentFilter) + return currentFilter->MessagePending(htaskCallee, dwTickCount, dwPendingType); + + return PENDINGMSG_WAITDEFPROCESS; + } +}; + +static void DisplayProgressbar() { + std::wcout << "displayProgressBar" << std::endl; +} + +static void ClearProgressbar() { + std::wcout << "clearprogressbar" << std::endl; +} + +inline const std::wstring QuoteString(const std::wstring& str) +{ + return L"\"" + str + L"\""; +} + +static std::wstring ErrorCodeToMsg(DWORD code) +{ + LPWSTR msgBuf = nullptr; + if (!FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, + nullptr, code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPWSTR)&msgBuf, 0, nullptr)) + { + return L"Unknown error"; + } + else + { + return msgBuf; + } +} + +// Get an environment variable +static std::wstring GetEnvironmentVariableValue(const std::wstring& variableName) { + DWORD currentBufferSize = MAX_PATH; + std::wstring variableValue; + variableValue.resize(currentBufferSize); + + DWORD requiredBufferSize = GetEnvironmentVariableW(variableName.c_str(), variableValue.data(), currentBufferSize); + if (requiredBufferSize == 0) { + // Environment variable probably does not exist. + return std::wstring(); + } + + if (currentBufferSize < requiredBufferSize) { + variableValue.resize(requiredBufferSize); + if (GetEnvironmentVariableW(variableName.c_str(), variableValue.data(), currentBufferSize) == 0) + return std::wstring(); + } + + variableValue.resize(requiredBufferSize); + return variableValue; +} + +static bool StartVisualStudioProcess( + const std::filesystem::path &visualStudioExecutablePath, + const std::filesystem::path &solutionPath, + DWORD *dwProcessId) { + + STARTUPINFOW si; + PROCESS_INFORMATION pi; + BOOL result; + + ZeroMemory(&si, sizeof(si)); + si.cb = sizeof(si); + ZeroMemory(&pi, sizeof(pi)); + + std::wstring startingDirectory = visualStudioExecutablePath.parent_path(); + + // Build the command line that is passed as the argv of the VS process + // argv[0] must be the quoted full path to the VS exe + std::wstringstream commandLineStream; + commandLineStream << QuoteString(visualStudioExecutablePath) << L" "; + + std::wstring vsArgsWide = GetEnvironmentVariableValue(L"UNITY_VS_ARGS"); + if (!vsArgsWide.empty()) + commandLineStream << vsArgsWide << L" "; + + commandLineStream << QuoteString(solutionPath); + + std::wstring commandLine = commandLineStream.str(); + + std::wcout << "Starting Visual Studio process with: " << commandLine << std::endl; + + result = CreateProcessW( + visualStudioExecutablePath.c_str(), // Full path to VS, must not be quoted + commandLine.data(), // Command line, as passed as argv, separate arguments must be quoted if they contain spaces + nullptr, // Process handle not inheritable + nullptr, // Thread handle not inheritable + false, // Set handle inheritance to FALSE + 0, // No creation flags + nullptr, // Use parent's environment block + startingDirectory.c_str(), // starting directory set to the VS directory + &si, + &pi); + + if (!result) { + DWORD error = GetLastError(); + std::wcout << "Starting Visual Studio process failed: " << ErrorCodeToMsg(error) << std::endl; + return false; + } + + *dwProcessId = pi.dwProcessId; + CloseHandle(pi.hProcess); + CloseHandle(pi.hThread); + + return true; +} + +static win::ComPtr FindRunningVisualStudioWithSolution( + const std::filesystem::path &visualStudioExecutablePath, + const std::filesystem::path &solutionPath) +{ + win::ComPtr punk = nullptr; + win::ComPtr dte = nullptr; + + CRetryMessageFilter retryMessageFilter; + + // Search through the Running Object Table for an instance of Visual Studio + // to use that either has the correct solution already open or does not have + // any solution open. + win::ComPtr ROT; + if (FAILED(GetRunningObjectTable(0, &ROT))) + return nullptr; + + win::ComPtr bindCtx; + if (FAILED(CreateBindCtx(0, &bindCtx))) + return nullptr; + + win::ComPtr enumMoniker; + if (FAILED(ROT->EnumRunning(&enumMoniker))) + return nullptr; + + win::ComPtr moniker; + ULONG monikersFetched = 0; + while (SUCCEEDED(enumMoniker->Next(1, &moniker, &monikersFetched)) && monikersFetched) { + if (FAILED(ROT->GetObject(moniker, &punk))) + continue; + + punk.As(&dte); + if (!dte) + continue; + + // Okay, so we found an actual running instance of Visual Studio. + + // Get the executable path of this running instance. + BStrHolder visualStudioFullName; + if (FAILED(dte->get_FullName(&visualStudioFullName))) + continue; + + std::filesystem::path currentVisualStudioExecutablePath = std::wstring(visualStudioFullName); + + // Ask for its current solution. + win::ComPtr solution; + if (FAILED(dte->get_Solution(&solution))) + continue; + + // Get the name of that solution. + BStrHolder solutionFullName; + if (FAILED(solution->get_FullName(&solutionFullName))) + continue; + + std::filesystem::path currentSolutionPath = std::wstring(solutionFullName); + if (!currentSolutionPath.empty()) + std::wcout << "Visual Studio opened on " << currentSolutionPath.wstring() << std::endl; + + // If the name matches the solution we want to open and we have a Visual Studio installation path to use and this one matches that path, then use it. + // If we don't have a Visual Studio installation path to use, just use this solution. + if (std::filesystem::equivalent(currentSolutionPath, solutionPath)) { + std::wcout << "We found a running Visual Studio session with the solution open." << std::endl; + if (!visualStudioExecutablePath.empty()) { + if (std::filesystem::equivalent(currentVisualStudioExecutablePath, visualStudioExecutablePath)) { + return dte; + } + else { + std::wcout << "This running Visual Studio session does not seem to be the version requested in the user preferences. We will keep looking." << std::endl; + } + } + else { + std::wcout << "We're not sure which version of Visual Studio was requested in the user preferences. We will use this running session." << std::endl; + return dte; + } + } + } + return nullptr; +} + +static bool +MonikerIsVisualStudioProcess(const win::ComPtr &moniker, const win::ComPtr &bindCtx, const DWORD dwProcessId) { + LPOLESTR oleMonikerName; + if (FAILED(moniker->GetDisplayName(bindCtx, nullptr, &oleMonikerName))) + return false; + + std::wstring monikerName(oleMonikerName); + + // VisualStudio Moniker is "!VisualStudio.DTE.$Version:$PID" + // Example "!VisualStudio.DTE.14.0:1234" + + if (monikerName.find(L"!VisualStudio.DTE") != 0) + return false; + + std::wstringstream suffixStream; + suffixStream << ":"; + suffixStream << dwProcessId; + + std::wstring suffix(suffixStream.str()); + + return monikerName.length() - suffix.length() == monikerName.find(suffix); +} + +static win::ComPtr FindRunningVisualStudioWithPID(const DWORD dwProcessId) { + win::ComPtr punk = nullptr; + win::ComPtr dte = nullptr; + + // Search through the Running Object Table for a Visual Studio + // process with the process ID specified + win::ComPtr ROT; + if (FAILED(GetRunningObjectTable(0, &ROT))) + return nullptr; + + win::ComPtr bindCtx; + if (FAILED(CreateBindCtx(0, &bindCtx))) + return nullptr; + + win::ComPtr enumMoniker; + if (FAILED(ROT->EnumRunning(&enumMoniker))) + return nullptr; + + win::ComPtr moniker; + ULONG monikersFetched = 0; + while (SUCCEEDED(enumMoniker->Next(1, &moniker, &monikersFetched)) && monikersFetched) { + if (FAILED(ROT->GetObject(moniker, &punk))) + continue; + + if (!MonikerIsVisualStudioProcess(moniker, bindCtx, dwProcessId)) + continue; + + punk.As(&dte); + if (dte) + return dte; + } + + return nullptr; +} + +static bool HaveRunningVisualStudioOpenFile(const win::ComPtr &dte, const std::filesystem::path &filename, int line) { + BStrHolder bstrFileName(filename.c_str()); + BStrHolder bstrKind(L"{00000000-0000-0000-0000-000000000000}"); // EnvDTE::vsViewKindPrimary + win::ComPtr window = nullptr; + + CRetryMessageFilter retryMessageFilter; + + if (!filename.empty()) { + std::wcout << "Getting operations API from the Visual Studio session." << std::endl; + + win::ComPtr item_ops; + if (FAILED(dte->get_ItemOperations(&item_ops))) + return false; + + std::wcout << "Waiting for the Visual Studio session to open the file: " << filename.wstring() << "." << std::endl; + + if (FAILED(item_ops->OpenFile(bstrFileName, bstrKind, &window))) + return false; + + if (line > 0) { + win::ComPtr selection_dispatch; + if (window && SUCCEEDED(window->get_Selection(&selection_dispatch))) { + win::ComPtr selection; + if (selection_dispatch && + SUCCEEDED(selection_dispatch->QueryInterface(__uuidof(EnvDTE::TextSelection), &selection)) && + selection) { + selection->GotoLine(line, false); + selection->EndOfLine(false); + } + } + } + } + + window = nullptr; + if (SUCCEEDED(dte->get_MainWindow(&window))) { + // Allow the DTE to make its main window the foreground + HWND hWnd; + window->get_HWnd((LONG *)&hWnd); + + DWORD processID; + if (SUCCEEDED(GetWindowThreadProcessId(hWnd, &processID))) + AllowSetForegroundWindow(processID); + + // Activate() set the window to visible and active (blinks in taskbar) + window->Activate(); + } + + return true; +} + +static bool VisualStudioOpenFile( + const std::filesystem::path &visualStudioExecutablePath, + const std::filesystem::path &solutionPath, + const std::filesystem::path &filename, + int line) +{ + win::ComPtr dte = nullptr; + + std::wcout << "Looking for a running Visual Studio session." << std::endl; + + // TODO: If path does not exist pass empty, which will just try to match all windows with solution + dte = FindRunningVisualStudioWithSolution(visualStudioExecutablePath, solutionPath); + + if (!dte) { + std::wcout << "No appropriate running Visual Studio session not found, creating a new one." << std::endl; + + DisplayProgressbar(); + + DWORD dwProcessId; + if (!StartVisualStudioProcess(visualStudioExecutablePath, solutionPath, &dwProcessId)) { + ClearProgressbar(); + return false; + } + + int timeWaited = 0; + + while (timeWaited < TIMEOUT_MS) { + dte = FindRunningVisualStudioWithPID(dwProcessId); + + if (dte) + break; + + std::wcout << "Retrying to acquire DTE" << std::endl; + + Sleep(RETRY_INTERVAL_MS); + timeWaited += RETRY_INTERVAL_MS; + } + + ClearProgressbar(); + + if (!dte) + return false; + } + else { + std::wcout << "Using the existing Visual Studio session." << std::endl; + } + + return HaveRunningVisualStudioOpenFile(dte, filename, line); +} + +int wmain(int argc, wchar_t* argv[]) { + if (argc != 3 && argc != 5) { + std::wcerr << argc << ": wrong number of arguments\n" << "Usage: com.exe installationPath solutionPath [fileName lineNumber]" << std::endl; + for (int i = 0; i < argc; i++) { + std::wcerr << argv[i] << std::endl; + } + return EXIT_FAILURE; + } + + if (FAILED(CoInitialize(nullptr))) { + std::wcerr << "CoInitialize failed." << std::endl; + return EXIT_FAILURE; + } + + std::filesystem::path visualStudioExecutablePath = std::filesystem::absolute(argv[1]); + std::filesystem::path solutionPath = std::filesystem::absolute(argv[2]); + + if (argc == 3) { + VisualStudioOpenFile(visualStudioExecutablePath, solutionPath, L"", -1); + return EXIT_SUCCESS; + } + + std::filesystem::path fileName = std::filesystem::absolute(argv[3]); + int lineNumber = std::stoi(argv[4]); + + VisualStudioOpenFile(visualStudioExecutablePath, solutionPath, fileName, lineNumber); + return EXIT_SUCCESS; +} diff --git a/Editor/COMIntegration/COMIntegration~/COMIntegration.cpp.meta b/Editor/COMIntegration/COMIntegration~/COMIntegration.cpp.meta new file mode 100644 index 0000000..d0e71d6 --- /dev/null +++ b/Editor/COMIntegration/COMIntegration~/COMIntegration.cpp.meta @@ -0,0 +1,27 @@ +fileFormatVersion: 2 +guid: 6ffa4010724f8d54aacbed867d4a5aa6 +PluginImporter: + externalObjects: {} + serializedVersion: 2 + iconMap: {} + executionOrder: {} + defineConstraints: [] + isPreloaded: 0 + isOverridable: 1 + isExplicitlyReferenced: 0 + validateReferences: 1 + platformData: + - first: + Any: + second: + enabled: 1 + settings: {} + - first: + Editor: Editor + second: + enabled: 0 + settings: + DefaultValueInitialized: true + userData: + assetBundleName: + assetBundleVariant: diff --git a/Editor/COMIntegration/COMIntegration~/ComPtr.h b/Editor/COMIntegration/COMIntegration~/ComPtr.h new file mode 100644 index 0000000..d5b8eb8 --- /dev/null +++ b/Editor/COMIntegration/COMIntegration~/ComPtr.h @@ -0,0 +1,186 @@ +#pragma once + +namespace win +{ + template + class ComPtr; + + template + class ComPtrRef + { + private: + ComPtr& m_ComPtr; + + ComPtrRef(ComPtr& comPtr) : + m_ComPtr(comPtr) + { + } + + friend class ComPtr; + + public: + inline operator T**() + { + return m_ComPtr.ReleaseAndGetAddressOf(); + } + + inline operator void**() + { + return reinterpret_cast(m_ComPtr.ReleaseAndGetAddressOf()); + } + + inline T* operator*() throw () + { + return m_ComPtr; + } + + }; + + template + class ComPtr + { + private: + T *ptr; + + public: + inline ComPtr(void) : ptr(NULL) {} + inline ~ComPtr(void) { this->Free(); } + + ComPtr(T *ptr) + { + if (NULL != (this->ptr = ptr)) + { + this->ptr->AddRef(); + } + } + + ComPtr(const ComPtr &ptr) + { + if (NULL != (this->ptr = ptr.ptr)) + { + this->ptr->AddRef(); + } + } + + inline bool operator!() const + { + return (NULL == this->ptr); + } + + inline operator T*() const { return this->ptr; } + + inline T *operator->() const + { + //_assert(NULL != this->ptr); + return this->ptr; + } + + inline T &operator*() + { + //_assert(NULL != this->ptr); + return *this->ptr; + } + + inline ComPtrRef operator&() + { + return ComPtrRef(*this); + } + + const ComPtr &operator=(T *ptr) + { + if (this->ptr != ptr) + { + this->Free(); + + if (NULL != (this->ptr = ptr)) + { + this->ptr->AddRef(); + } + } + + return *this; + } + + const ComPtr &operator=(const ComPtr &ptr) + { + if (this->ptr != ptr.ptr) + { + this->Free(); + + if (NULL != (this->ptr = ptr.ptr)) + { + this->ptr->AddRef(); + } + } + + return *this; + } + + void Free(void) + { + if (NULL != this->ptr) + { + this->ptr->Release(); + this->ptr = NULL; + } + } + + inline T** ReleaseAndGetAddressOf() + { + Free(); + return &ptr; + } + + template + inline HRESULT As(ComPtrRef p) const throw () + { + return ptr->QueryInterface(__uuidof(U), p); + } + + inline bool operator==(std::nullptr_t) const + { + return this->ptr == nullptr; + } + + template + inline bool operator==(U* other) + { + if (ptr == nullptr || other == nullptr) + return ptr == other; + + ComPtr meUnknown; + ComPtr otherUnknown; + + if (FAILED(this->ptr->QueryInterface(__uuidof(IUnknown), &meUnknown))) + return false; + + if (FAILED(other->QueryInterface(__uuidof(IUnknown), &otherUnknown))) + return false; + + return static_cast(meUnknown) == static_cast(otherUnknown); + } + + template + inline bool operator==(ComPtr& other) + { + return *this == static_cast(other); + } + + inline bool operator!=(std::nullptr_t) const + { + return this->ptr != nullptr; + } + + template + inline bool operator!=(U* other) + { + return !(*this == other); + } + + template + inline bool operator!=(ComPtr& other) + { + return *this != static_cast(other); + } + }; +} diff --git a/Editor/COMIntegration/COMIntegration~/ComPtr.h.meta b/Editor/COMIntegration/COMIntegration~/ComPtr.h.meta new file mode 100644 index 0000000..261d1c0 --- /dev/null +++ b/Editor/COMIntegration/COMIntegration~/ComPtr.h.meta @@ -0,0 +1,26 @@ +fileFormatVersion: 2 +guid: 013868b12dff0dc43adcc33513ae71bf +PluginImporter: + externalObjects: {} + serializedVersion: 2 + iconMap: {} + executionOrder: {} + defineConstraints: [] + isPreloaded: 0 + isOverridable: 1 + isExplicitlyReferenced: 0 + platformData: + - first: + Any: + second: + enabled: 1 + settings: {} + - first: + Editor: Editor + second: + enabled: 0 + settings: + DefaultValueInitialized: true + userData: + assetBundleName: + assetBundleVariant: diff --git a/Editor/COMIntegration/COMIntegration~/dte80a.tlh b/Editor/COMIntegration/COMIntegration~/dte80a.tlh new file mode 100644 index 0000000..6f5e532 --- /dev/null +++ b/Editor/COMIntegration/COMIntegration~/dte80a.tlh @@ -0,0 +1,7538 @@ +// Created by Microsoft (R) C/C++ Compiler Version 14.13.26128.0 (73c17aba). +// +// c:\projects\unity1\artifacts\editorapp\win64_debug_vs2017\dte80a.tlh +// +// C++ source equivalent of Win32 type library 80cc9f66-e7d8-4ddd-85b6-d9e6cd0e93e2 +// compiler-generated file created 05/30/18 at 11:33:08 - DO NOT EDIT! + +#pragma once +#pragma pack(push, 8) + +#include + +namespace EnvDTE { + + // + // Forward references and typedefs + // + + struct __declspec(uuid("80cc9f66-e7d8-4ddd-85b6-d9e6cd0e93e2")) + /* LIBID */ __EnvDTE; + struct __declspec(uuid("04a72314-32e9-48e2-9b87-a63603454f3e")) + /* dual interface */ _DTE; + struct __declspec(uuid("2294311a-b7bc-4789-b365-1c15ff2cd17c")) + /* dual interface */ Windows; + struct __declspec(uuid("0beab46b-4c07-4f94-a8d7-1626020e4e53")) + /* dual interface */ Window; + enum vsWindowState; + enum vsWindowType; + struct __declspec(uuid("f00ef34a-a654-4c1b-897a-585d5bcbb35a")) + /* dual interface */ LinkedWindows; + struct /* coclass */ DTE; + struct __declspec(uuid("0b48100a-473e-433c-ab8f-66b9739ab620")) + /* dual interface */ ProjectItem; + struct __declspec(uuid("8e2f1269-185e-43c7-8899-950ad2769ccf")) + /* dual interface */ ProjectItems; + struct __declspec(uuid("866311e6-c887-4143-9833-645f5b93f6f1")) + /* dual interface */ Project; + struct __declspec(uuid("e3ec0add-31b3-461f-8303-8a5e6931257a")) + /* dual interface */ Projects; + struct __declspec(uuid("4cc8ccf5-a926-4646-b17f-b4940caed472")) + /* dual interface */ Properties; + struct __declspec(uuid("7b988e06-2581-485e-9322-04881e0600d0")) + /* dual interface */ Property; + struct __declspec(uuid("9043fda1-345b-4364-900f-bc8598eb8e4f")) + /* dual interface */ ConfigurationManager; + struct __declspec(uuid("90813589-fe21-4aa4-a2e5-053fd274e980")) + /* dual interface */ Configuration; + enum vsConfigurationType; + struct __declspec(uuid("f9fa748e-e302-44cf-891b-e263189d585e")) + /* dual interface */ OutputGroups; + struct __declspec(uuid("a3a80783-875f-435b-9639-e5ce888df737")) + /* dual interface */ OutputGroup; + struct __declspec(uuid("b6b4c8d6-4d27-43b9-b45c-52bd16b6ba38")) + /* dual interface */ Configurations; + struct __declspec(uuid("e68a3e0e-b435-4dde-86b7-f5adefc19df2")) + /* dual interface */ Globals; + struct __declspec(uuid("0cfbc2b4-0d4e-11d3-8997-00c04f688dde")) + /* dual interface */ CodeModel; + struct __declspec(uuid("0cfbc2b5-0d4e-11d3-8997-00c04f688dde")) + /* dual interface */ CodeElements; + struct __declspec(uuid("0cfbc2b6-0d4e-11d3-8997-00c04f688dde")) + /* dual interface */ CodeElement; + enum vsCMElement; + enum vsCMInfoLocation; + struct __declspec(uuid("7f59e94e-4939-40d2-9f7f-b7651c25905d")) + /* dual interface */ TextPoint; + struct __declspec(uuid("cb218890-1382-472b-9118-782700c88115")) + /* dual interface */ TextDocument; + struct __declspec(uuid("63eb5c39-ca8f-498e-9a66-6dd4a27ac95b")) + /* dual interface */ Document; + struct __declspec(uuid("9e2cf3ea-140f-413e-bd4b-7d46740cd2f4")) + /* dual interface */ Documents; + enum vsSaveChanges; + enum vsSaveStatus; + struct __declspec(uuid("1fa0e135-399a-4d2c-a4fe-d21e2480f921")) + /* dual interface */ TextSelection; + struct __declspec(uuid("42320454-626c-4dd0-9ecb-357c4f1966d8")) + /* dual interface */ VirtualPoint; + enum vsCaseOptions; + enum vsWhitespaceOptions; + enum vsStartOfLineOptions; + struct __declspec(uuid("b6422e9c-9efd-4f87-bddc-c7fd8f2fd303")) + /* dual interface */ TextRanges; + struct __declspec(uuid("72767524-e3b3-43d0-bb46-bbe1d556a9ff")) + /* dual interface */ TextRange; + struct __declspec(uuid("c1ffe800-028b-4475-a907-14f51f19bb7d")) + /* dual interface */ EditPoint; + struct __declspec(uuid("0a3bf283-05f8-4669-9bcb-a84b6423349a")) + /* dual interface */ TextPane; + struct __declspec(uuid("d9013d31-3652-46b2-a25a-29a881b9f86b")) + /* dual interface */ TextPanes; + struct __declspec(uuid("2fc54dc9-922b-44eb-8cc0-ba182584dc4b")) + /* dual interface */ TextWindow; + enum vsPaneShowHow; + enum vsSelectionMode; + enum vsCMPart; + struct __declspec(uuid("0cfbc2b7-0d4e-11d3-8997-00c04f688dde")) + /* dual interface */ CodeType; + struct __declspec(uuid("0cfbc2b8-0d4e-11d3-8997-00c04f688dde")) + /* dual interface */ CodeNamespace; + enum vsCMAccess; + struct __declspec(uuid("b1f42514-91cd-4d3a-8b25-a317d8032b24")) + /* dual interface */ CodeClass; + struct __declspec(uuid("0cfbc2be-0d4e-11d3-8997-00c04f688dde")) + /* dual interface */ CodeAttribute; + struct __declspec(uuid("b1f42510-91cd-4d3a-8b25-a317d8032b24")) + /* dual interface */ CodeInterface; + enum vsCMFunction; + struct __declspec(uuid("0cfbc2b9-0d4e-11d3-8997-00c04f688dde")) + /* dual interface */ CodeFunction; + struct __declspec(uuid("0cfbc2bc-0d4e-11d3-8997-00c04f688dde")) + /* dual interface */ CodeTypeRef; + enum vsCMTypeRef; + struct __declspec(uuid("0cfbc2bd-0d4e-11d3-8997-00c04f688dde")) + /* dual interface */ CodeParameter; + struct __declspec(uuid("0cfbc2bb-0d4e-11d3-8997-00c04f688dde")) + /* dual interface */ CodeProperty; + struct __declspec(uuid("0cfbc2ba-0d4e-11d3-8997-00c04f688dde")) + /* dual interface */ CodeVariable; + struct __declspec(uuid("b1f42511-91cd-4d3a-8b25-a317d8032b24")) + /* dual interface */ CodeStruct; + struct __declspec(uuid("b1f42512-91cd-4d3a-8b25-a317d8032b24")) + /* dual interface */ CodeEnum; + struct __declspec(uuid("b1f42513-91cd-4d3a-8b25-a317d8032b24")) + /* dual interface */ CodeDelegate; + struct __declspec(uuid("ed1a3f99-4477-11d3-89bf-00c04f688dde")) + /* dual interface */ FileCodeModel; + struct __declspec(uuid("33c5ebb8-244e-449d-9cee-fad70a774e59")) + /* dual interface */ ContextAttributes; + struct __declspec(uuid("1a6e2cb3-b897-42eb-96be-ff0fdb65db2f")) + /* dual interface */ ContextAttribute; + enum vsContextAttributeType; + enum vsContextAttributes; + struct __declspec(uuid("53a87fa1-ce93-48bf-958b-c6da793c5028")) + /* dual interface */ AddIn; + struct __declspec(uuid("50590801-d13e-4404-80c2-5ca30a4d0ee8")) + /* dual interface */ AddIns; + enum vsLinkedWindowType; + struct __declspec(uuid("134170f8-93b1-42dd-9f89-a2ac7010ba07")) + /* dual interface */ Events; + struct /* coclass */ CommandEvents; + struct __declspec(uuid("a79fc678-0d0a-496a-b9dc-0d5b9e1ca9fc")) + /* interface */ _CommandEvents; + struct __declspec(uuid("ff2d5c12-feea-11d0-bbc8-00a0c90f2744")) + /* dispinterface */ _dispCommandEvents; + struct /* coclass */ SelectionEvents; + struct __declspec(uuid("eb6783db-1819-496d-84a4-3cff883010f6")) + /* interface */ _SelectionEvents; + struct __declspec(uuid("deeb28b3-23e6-11d1-ae5c-00a0c90f26f4")) + /* dispinterface */ _dispSelectionEvents; + struct /* coclass */ SolutionEvents; + struct __declspec(uuid("bf8bbf37-5415-46a9-940d-594cad9dec26")) + /* interface */ _SolutionEvents; + struct __declspec(uuid("fbcff1c2-261c-11d1-ae5e-00a0c90f26f4")) + /* dispinterface */ _dispSolutionEvents; + struct /* coclass */ BuildEvents; + struct __declspec(uuid("794a2ba5-ffa6-4fc5-bf13-957b2c22edd7")) + /* interface */ _BuildEvents; + struct __declspec(uuid("1926364e-6b90-46cb-a44d-8a80fb11acd9")) + /* dispinterface */ _dispBuildEvents; + enum vsBuildScope; + enum vsBuildAction; + struct /* coclass */ WindowEvents; + struct __declspec(uuid("0d3a23a8-67bb-11d2-97c1-00c04fb6c6ff")) + /* interface */ _WindowEvents; + struct __declspec(uuid("0d3a23a9-67bb-11d2-97c1-00c04fb6c6ff")) + /* dispinterface */ _dispWindowEvents; + struct /* coclass */ OutputWindowEvents; + struct __declspec(uuid("0a3546a8-6840-11d2-97c1-00c04fb6c6ff")) + /* interface */ _OutputWindowEvents; + struct __declspec(uuid("0d3a23af-67bb-11d2-97c1-00c04fb6c6ff")) + /* dispinterface */ _dispOutputWindowEvents; + struct __declspec(uuid("ffc9dfc4-61ca-4b0c-83c2-0703a24f5c16")) + /* dual interface */ OutputWindowPane; + struct __declspec(uuid("b02cf62a-9470-4308-a521-9675fba395ab")) + /* dual interface */ OutputWindowPanes; + struct __declspec(uuid("eab0a63d-c3a8-496e-9acf-a82cef6a43b3")) + /* dual interface */ OutputWindow; + enum vsTaskPriority; + enum vsTaskIcon; + struct /* coclass */ FindEvents; + struct __declspec(uuid("c5331acd-c5d5-11d2-8598-006097c68e81")) + /* interface */ _FindEvents; + struct __declspec(uuid("c5331ace-c5d5-11d2-8598-006097c68e81")) + /* dispinterface */ _dispFindEvents; + enum vsFindResult; + struct /* coclass */ TaskListEvents; + struct __declspec(uuid("1125c422-49bd-11d2-8823-00c04fb6c6ff")) + /* interface */ _TaskListEvents; + struct __declspec(uuid("1125c423-49bd-11d2-8823-00c04fb6c6ff")) + /* dispinterface */ _dispTaskListEvents; + struct __declspec(uuid("58e4d419-6b8c-4c63-92de-70161cd95890")) + /* dual interface */ TaskItem; + struct __declspec(uuid("4b51103d-513c-4773-b56a-354d0928fd04")) + /* dual interface */ TaskItems; + struct __declspec(uuid("4e4f0569-e16a-4da1-92de-10882a4ddd8c")) + /* dual interface */ TaskList; + enum vsTaskListColumn; + struct /* coclass */ DTEEvents; + struct __declspec(uuid("fa1bb6d7-ca83-11d2-aab2-00c04f688dde")) + /* interface */ _DTEEvents; + struct __declspec(uuid("b50c9708-c909-4b87-a03d-af6cc4bfb422")) + /* dispinterface */ _dispDTEEvents; + enum vsIDEMode; + struct /* coclass */ DocumentEvents; + struct __declspec(uuid("dc5437f5-f114-11d2-aacf-00c04f688dde")) + /* interface */ _DocumentEvents; + struct __declspec(uuid("dc5437f6-f114-11d2-aacf-00c04f688dde")) + /* dispinterface */ _dispDocumentEvents; + struct /* coclass */ ProjectItemsEvents; + struct __declspec(uuid("22800963-2811-410d-bf87-a7808eac977d")) + /* dual interface */ _ProjectItemsEvents; + struct __declspec(uuid("6962753f-efd5-41c5-b083-d70687166aeb")) + /* dispinterface */ _dispProjectItemsEvents; + struct /* coclass */ DebuggerEvents; + struct __declspec(uuid("d4eae958-0fba-11d3-b880-00c04f79e479")) + /* interface */ _DebuggerEvents; + struct __declspec(uuid("46209330-0fba-11d3-b880-00c04f79e479")) + /* dispinterface */ _dispDebuggerEvents; + enum dbgEventReason; + enum dbgExecutionAction; + enum dbgExceptionAction; + struct __declspec(uuid("5c5a0070-f396-4e37-a82a-1b767e272df9")) + /* dual interface */ Process; + struct __declspec(uuid("dc6a118a-bbab-11d2-8ad1-00c04f79e479")) + /* dual interface */ Programs; + struct __declspec(uuid("6a38d87c-bba0-11d2-8ad1-00c04f79e479")) + /* dual interface */ Program; + struct __declspec(uuid("6aa23fb4-bba1-11d2-8ad1-00c04f79e479")) + /* dual interface */ Threads; + struct __declspec(uuid("9407f466-bba1-11d2-8ad1-00c04f79e479")) + /* dual interface */ Thread; + struct __declspec(uuid("4ed85664-bba2-11d2-8ad1-00c04f79e479")) + /* dual interface */ StackFrames; + struct __declspec(uuid("1342d0d8-bba3-11d2-8ad1-00c04f79e479")) + /* dual interface */ StackFrame; + struct __declspec(uuid("2685337a-bb9e-11d2-8ad1-00c04f79e479")) + /* dual interface */ Expressions; + struct __declspec(uuid("27adc812-bb07-11d2-8ad1-00c04f79e479")) + /* dual interface */ Expression; + struct __declspec(uuid("338fb9a0-bae5-11d2-8ad1-00c04f79e479")) + /* dual interface */ Debugger; + struct __declspec(uuid("25968106-bafb-11d2-8ad1-00c04f79e479")) + /* dual interface */ Breakpoints; + struct __declspec(uuid("11c5114c-bb00-11d2-8ad1-00c04f79e479")) + /* dual interface */ Breakpoint; + enum dbgBreakpointType; + enum dbgBreakpointLocationType; + enum dbgBreakpointConditionType; + enum dbgHitCountType; + struct __declspec(uuid("a4f4246c-c131-11d2-8ad1-00c04f79e479")) + /* dual interface */ Languages; + struct __declspec(uuid("b3ccfa68-c145-11d2-8ad1-00c04f79e479")) + /* dual interface */ Language; + enum dbgDebugMode; + struct __declspec(uuid("9f379969-5eac-4a54-b2bc-6946cffb56ef")) + /* dual interface */ Processes; + struct /* coclass */ TextEditorEvents; + struct __declspec(uuid("23b7a868-6c89-436a-94fa-25d755456a77")) + /* interface */ _TextEditorEvents; + struct __declspec(uuid("2699dd44-c507-4da3-aa34-314a6c21dfe2")) + /* dispinterface */ _dispTextEditorEvents; + enum vsDisplay; + struct /* coclass */ Solution; + struct __declspec(uuid("26f6cc4b-7a48-4e4d-8af5-9e960232e05f")) + /* dual interface */ _Solution; + struct __declspec(uuid("a3c1c40c-9218-4d4c-9daa-075f64f6922c")) + /* dual interface */ SolutionBuild; + struct __declspec(uuid("60aaad75-cb8d-4c62-9959-24d6a6a50de7")) + /* dual interface */ SolutionConfiguration; + struct __declspec(uuid("23e78ed7-c9e1-462d-8bc6-366003486ed9")) + /* dual interface */ SolutionConfigurations; + struct __declspec(uuid("0685b546-fb84-4917-ab98-98d40f892d61")) + /* dual interface */ SolutionContexts; + struct __declspec(uuid("fc6a1a82-9c8a-47bb-a046-6e965df5a99b")) + /* dual interface */ SolutionContext; + struct __declspec(uuid("ead260eb-1e5b-450a-b628-4cfada11b4a1")) + /* dual interface */ BuildDependencies; + struct __declspec(uuid("9c5ceaac-062f-4434-a2ed-78ab4d6134fe")) + /* dual interface */ BuildDependency; + enum vsBuildState; + struct __declspec(uuid("e6b96cac-b8c7-40ae-b705-5c81878c4a9e")) + /* dual interface */ Commands; + struct __declspec(uuid("5fe10fb0-91a1-4e55-baaa-eccae5cceb94")) + /* dual interface */ Command; + enum vsCommandBarType; + struct __declspec(uuid("6caa67cf-43ae-4184-aaab-0200ddf6b240")) + /* dual interface */ SelectedItems; + struct __declspec(uuid("049d2cdf-3731-4cb6-a233-be97bce922d3")) + /* dual interface */ SelectedItem; + struct __declspec(uuid("02273422-8dd4-4a9f-8a8b-d70443d510f4")) + /* dual interface */ SelectionContainer; + struct __declspec(uuid("e577442a-98e1-46c5-bd2e-d25807ec81ce")) + /* dual interface */ WindowConfigurations; + struct __declspec(uuid("41d02413-8a67-4c28-a980-ad7539ed415d")) + /* dual interface */ WindowConfiguration; + struct __declspec(uuid("c34301a1-3ef1-41d8-932a-fea4a8a8ce0c")) + /* dual interface */ StatusBar; + struct __declspec(uuid("8d0aa9cc-8465-42f3-ad6e-dfde28ccc75d")) + /* dual interface */ ObjectExtenders; + struct __declspec(uuid("4db06329-23f4-443b-9abd-9cf611e8ae07")) + /* dual interface */ IExtenderProvider; + struct __declspec(uuid("e57c510b-968b-4a3c-a467-ee4013157dc9")) + /* dual interface */ IExtenderSite; + struct __declspec(uuid("f69b64a3-9017-4e48-9784-e152b51aa722")) + /* dual interface */ IExtenderProviderUnk; + struct __declspec(uuid("40d4b9b6-739b-4965-8d65-692aec692266")) + /* dual interface */ Find; + enum vsFindAction; + enum vsFindPatternSyntax; + enum vsFindTarget; + enum vsFindResultsLocation; + enum wizardResult; + struct __declspec(uuid("d5dbe57b-c074-4e95-b015-abeeaa391693")) + /* dual interface */ ItemOperations; + enum vsNavigateOptions; + enum vsPromptResult; + struct __declspec(uuid("d8dec44d-caf2-4b39-a539-b91ae921ba92")) + /* dual interface */ UndoContext; + struct __declspec(uuid("f9f99155-6d4d-49b1-ad63-c78c3e8a5916")) + /* dual interface */ Macros; + struct __declspec(uuid("f1ddc2c2-df76-4ebb-9de8-48ad2557062c")) + /* dual interface */ SourceControl; + struct __declspec(uuid("f47dc7e7-84b6-474f-bb91-631640aa0560")) + /* dual interface */ TextBuffer; + struct __declspec(uuid("6659ed14-2ab6-47f3-a890-00c8aba43b84")) + /* interface */ ISupportVSProperties; + struct __declspec(uuid("56fcd5af-7f17-4c5c-aa8d-ae2bb2ddbf38")) + /* dual interface */ ToolBox; + struct __declspec(uuid("ce2def9e-3387-4bf2-967b-a1f7f70df325")) + /* dual interface */ ToolBoxTab; + struct __declspec(uuid("cf177b52-4f2f-42a0-8da3-ce78679a0d2d")) + /* dual interface */ ToolBoxTabs; + struct __declspec(uuid("395c7dfb-f158-431c-8f43-dda83b4ef54e")) + /* dual interface */ ToolBoxItems; + struct __declspec(uuid("46538d1b-4d81-4002-8bb4-dbdb65babb23")) + /* dual interface */ ToolBoxItem; + enum vsToolBoxItemFormat; + struct __declspec(uuid("eb5be8a7-e593-4de6-a923-c2afecb96336")) + /* interface */ IExtensibleObjectSite; + struct __declspec(uuid("8cc0cde1-c16a-4749-99af-6f7523c34a57")) + /* interface */ IVsProfferCommands; + struct __declspec(uuid("aade1f59-6ace-43d1-8fca-42af3a5c4f3c")) + /* dual interface */ IFilterProperties; + enum vsFilterProperties; + struct __declspec(uuid("fbd0d024-09cd-4d9f-9e2b-cacd628426a5")) + /* dual interface */ UIHierarchyItem; + struct __declspec(uuid("db8406b0-a916-449c-a277-bb04028f4394")) + /* dual interface */ UIHierarchyItems; + enum vsUISelectionType; + struct __declspec(uuid("72a2a2ef-c209-408c-a377-76871774adb7")) + /* dual interface */ UIHierarchy; + struct __declspec(uuid("9ff3ddca-1795-4191-a5b1-02d1ae35d074")) + /* dual interface */ TextEditor; + enum vsCMPrototype; + struct __declspec(uuid("d4bb39fb-0f0e-11d3-b880-00c04f79e479")) + /* dual interface */ _DebuggerEventsRoot; + enum vsNavigateBrowser; + enum vsCommandDisabledFlags; + enum vsInitializeMode; + struct __declspec(uuid("e914bbe1-03a4-11d1-bbcd-00a0c90f2744")) + /* dual interface */ IDTWizard; + struct __declspec(uuid("3c536122-57b1-46de-ab34-acc524140093")) + /* interface */ IVsExtensibility; + struct __declspec(uuid("e2cc506a-588b-4f65-a1f0-2244c060abcb")) + /* interface */ IVsGlobalsCallback; + struct __declspec(uuid("192ac688-e7c6-4f9d-8180-4b37efbf6f3a")) + /* interface */ IVsGlobals; + enum vsCommandStatusTextWanted; + enum vsCommandStatus; + enum vsCommandExecOption; + struct __declspec(uuid("7ef39a3e-590d-4879-88d4-c9be5bcfd92e")) + /* dual interface */ IDTCommandTarget; + struct __declspec(uuid("509b9955-7303-48c9-90d4-e165b974e6ba")) + /* dual interface */ CommandWindow; + struct __declspec(uuid("85451f83-b5ca-437f-a619-0cb705707420")) + /* dual interface */ _ProjectsEvents; + struct __declspec(uuid("7f508d55-627f-4d7f-be0b-9e3d829ff0ed")) + /* dispinterface */ _dispProjectsEvents; + struct /* coclass */ ProjectsEvents; + struct __declspec(uuid("7658b944-f37b-11d2-aacf-00c04f688dde")) + /* dual interface */ _MiscSlnFilesEventsRoot; + struct __declspec(uuid("9e66fe98-a1c6-421d-8c0c-6da4e652e770")) + /* interface */ _CommandBarControlEvents; + struct __declspec(uuid("987fb893-f96d-11d0-bbbb-00a0c90f2744")) + /* dispinterface */ _dispCommandBarControlEvents; + struct /* coclass */ CommandBarEvents; + enum vsBuildKind; + struct __declspec(uuid("dc5437f4-f114-11d2-aacf-00c04f688dde")) + /* dual interface */ _DocumentEventsRoot; + enum vsTextChanged; + struct __declspec(uuid("b3c38885-b288-44a8-b290-34fe63bf3c76")) + /* dual interface */ _TextEditorEventsRoot; + struct __declspec(uuid("17d12026-ba99-403e-a359-71fd1e5a72cd")) + /* dual interface */ _WindowEventsRoot; + struct __declspec(uuid("aa6f4085-33b6-4629-b9ea-692101007cc2")) + /* dual interface */ _OutputWindowEventsRoot; + struct __declspec(uuid("6bc8c372-c6f0-4be6-b255-827ac190bf71")) + /* dual interface */ _TaskListEventsRoot; + enum vsStatusAnimation; + struct __declspec(uuid("bdcaf240-2692-4713-902a-b110b1d0f100")) + /* dual interface */ IDTToolsOptionsPage; + enum vsStartUp; + enum vsFontCharSet; + enum vsBrowserViewSource; + struct __declspec(uuid("a3286b03-5ac6-44f0-8cc3-ebed7f1124e5")) + /* dual interface */ _EnvironmentWebBrowser; + struct __declspec(uuid("aebded64-a206-11d3-b8b5-00c04f79f802")) + /* dual interface */ _EnvironmentHelp; + struct __declspec(uuid("e5d17051-d6e5-4da7-8b3a-ca888617a5e7")) + /* dual interface */ ColorableItems; + struct __declspec(uuid("f25ae7e6-1460-4ba4-8e5e-bbbe746de353")) + /* dual interface */ FontsAndColorsItems; + struct __declspec(uuid("256068f6-1add-4f7b-ba76-571314c413ad")) + /* dual interface */ _FontsAndColors; + struct __declspec(uuid("48e61d9c-8c8d-42d3-914b-46d70c8b7a40")) + /* dual interface */ _EnvironmentGeneral; + struct __declspec(uuid("f809cab6-2c9f-41f2-a5af-e26fb80e62ad")) + /* dual interface */ _EnvironmentFontsAndColors; + struct __declspec(uuid("478f06d4-5d57-473f-9b74-5f8e88efa5e7")) + /* dual interface */ _EnvironmentProjectsAndSolution; + struct __declspec(uuid("76ed1c48-ed86-4e9e-acf8-a40e765daf25")) + /* dual interface */ _EnvironmentDocuments; + struct __declspec(uuid("4bc18a5b-dbb6-4af5-a443-2e3f19365304")) + /* dual interface */ _EnvironmentTaskList; + struct __declspec(uuid("9c722678-490d-408f-98ae-b6b9a68aa45d")) + /* dual interface */ _EnvironmentKeyboard; + struct __declspec(uuid("86c31347-5b52-4715-b454-a6e5fcab975d")) + /* interface */ IExtensibleObject; + enum vsFindOptions; + enum vsMovementOptions; + enum vsGoToLineOptions; + enum vsSmartFormatOptions; + enum vsInsertFlags; + enum vsMoveToColumnLine; + enum vsEPReplaceTextOptions; + struct __declspec(uuid("2e1bfd1c-5b26-4aca-b97b-ed9d261ba3e7")) + /* dual interface */ IVsTextEditGeneral; + struct __declspec(uuid("5943bd7e-d722-42db-a251-fe2add8711ea")) + /* dual interface */ IVsTextEditPerLanguage; + enum _vsIndentStyle; + struct __declspec(uuid("f39ab913-e6c9-4546-a265-1e43f8de924c")) + /* dual interface */ IVsTextEditFonts; + enum vsext_FontCharSet; + enum VSEXECRESULT; + enum vsext_DisplayMode; + enum vsext_WindowType; + enum vsext_WindowState; + enum vsext_LinkedWindowType; + enum vsext_StartUp; + enum vsext_Build; + enum DsTextSearchOptions; + enum DsSaveChanges; + enum DsGoToLineOptions; + enum DsStartOfLineOptions; + enum DsMovementOptions; + enum DsWhitespaceOptions; + enum DsCaseOptions; + enum dsSaveStatus; + enum vsHTMLTabs; + struct __declspec(uuid("f6576203-fbce-477e-a66b-eda237bb68a7")) + /* dual interface */ HTMLWindow; +#if !defined(_WIN64) + typedef __w64 unsigned long ULONG_PTR; +#else + typedef unsigned __int64 ULONG_PTR; +#endif +#if !defined(_WIN64) + typedef __w64 long LONG_PTR; +#else + typedef __int64 LONG_PTR; +#endif + typedef enum _vsIndentStyle vsIndentStyle; + typedef enum VSEXECRESULT vs_exec_Result; + + // + // Smart pointer typedef declarations + // + + _COM_SMARTPTR_TYPEDEF(Globals, __uuidof(Globals)); + _COM_SMARTPTR_TYPEDEF(_CommandEvents, __uuidof(_CommandEvents)); + _COM_SMARTPTR_TYPEDEF(_dispCommandEvents, __uuidof(_dispCommandEvents)); + _COM_SMARTPTR_TYPEDEF(_SelectionEvents, __uuidof(_SelectionEvents)); + _COM_SMARTPTR_TYPEDEF(_dispSelectionEvents, __uuidof(_dispSelectionEvents)); + _COM_SMARTPTR_TYPEDEF(_SolutionEvents, __uuidof(_SolutionEvents)); + _COM_SMARTPTR_TYPEDEF(_dispSolutionEvents, __uuidof(_dispSolutionEvents)); + _COM_SMARTPTR_TYPEDEF(_BuildEvents, __uuidof(_BuildEvents)); + _COM_SMARTPTR_TYPEDEF(_dispBuildEvents, __uuidof(_dispBuildEvents)); + _COM_SMARTPTR_TYPEDEF(_WindowEvents, __uuidof(_WindowEvents)); + _COM_SMARTPTR_TYPEDEF(_dispWindowEvents, __uuidof(_dispWindowEvents)); + _COM_SMARTPTR_TYPEDEF(_OutputWindowEvents, __uuidof(_OutputWindowEvents)); + _COM_SMARTPTR_TYPEDEF(_dispOutputWindowEvents, __uuidof(_dispOutputWindowEvents)); + _COM_SMARTPTR_TYPEDEF(_FindEvents, __uuidof(_FindEvents)); + _COM_SMARTPTR_TYPEDEF(_dispFindEvents, __uuidof(_dispFindEvents)); + _COM_SMARTPTR_TYPEDEF(_TaskListEvents, __uuidof(_TaskListEvents)); + _COM_SMARTPTR_TYPEDEF(_dispTaskListEvents, __uuidof(_dispTaskListEvents)); + _COM_SMARTPTR_TYPEDEF(_DTEEvents, __uuidof(_DTEEvents)); + _COM_SMARTPTR_TYPEDEF(_dispDTEEvents, __uuidof(_dispDTEEvents)); + _COM_SMARTPTR_TYPEDEF(_DocumentEvents, __uuidof(_DocumentEvents)); + _COM_SMARTPTR_TYPEDEF(_dispDocumentEvents, __uuidof(_dispDocumentEvents)); + _COM_SMARTPTR_TYPEDEF(_ProjectItemsEvents, __uuidof(_ProjectItemsEvents)); + _COM_SMARTPTR_TYPEDEF(_dispProjectItemsEvents, __uuidof(_dispProjectItemsEvents)); + _COM_SMARTPTR_TYPEDEF(_DebuggerEvents, __uuidof(_DebuggerEvents)); + _COM_SMARTPTR_TYPEDEF(_dispDebuggerEvents, __uuidof(_dispDebuggerEvents)); + _COM_SMARTPTR_TYPEDEF(_TextEditorEvents, __uuidof(_TextEditorEvents)); + _COM_SMARTPTR_TYPEDEF(_dispTextEditorEvents, __uuidof(_dispTextEditorEvents)); + _COM_SMARTPTR_TYPEDEF(StatusBar, __uuidof(StatusBar)); + _COM_SMARTPTR_TYPEDEF(IExtenderSite, __uuidof(IExtenderSite)); + _COM_SMARTPTR_TYPEDEF(IExtenderProvider, __uuidof(IExtenderProvider)); + _COM_SMARTPTR_TYPEDEF(IExtenderProviderUnk, __uuidof(IExtenderProviderUnk)); + _COM_SMARTPTR_TYPEDEF(ObjectExtenders, __uuidof(ObjectExtenders)); + _COM_SMARTPTR_TYPEDEF(Find, __uuidof(Find)); + _COM_SMARTPTR_TYPEDEF(UndoContext, __uuidof(UndoContext)); + _COM_SMARTPTR_TYPEDEF(Macros, __uuidof(Macros)); + _COM_SMARTPTR_TYPEDEF(SourceControl, __uuidof(SourceControl)); + _COM_SMARTPTR_TYPEDEF(ISupportVSProperties, __uuidof(ISupportVSProperties)); + _COM_SMARTPTR_TYPEDEF(IExtensibleObjectSite, __uuidof(IExtensibleObjectSite)); + _COM_SMARTPTR_TYPEDEF(IVsProfferCommands, __uuidof(IVsProfferCommands)); + _COM_SMARTPTR_TYPEDEF(IFilterProperties, __uuidof(IFilterProperties)); + _COM_SMARTPTR_TYPEDEF(TextEditor, __uuidof(TextEditor)); + _COM_SMARTPTR_TYPEDEF(_DebuggerEventsRoot, __uuidof(_DebuggerEventsRoot)); + _COM_SMARTPTR_TYPEDEF(IDTWizard, __uuidof(IDTWizard)); + _COM_SMARTPTR_TYPEDEF(IVsGlobalsCallback, __uuidof(IVsGlobalsCallback)); + _COM_SMARTPTR_TYPEDEF(IVsGlobals, __uuidof(IVsGlobals)); + _COM_SMARTPTR_TYPEDEF(IDTCommandTarget, __uuidof(IDTCommandTarget)); + _COM_SMARTPTR_TYPEDEF(_ProjectsEvents, __uuidof(_ProjectsEvents)); + _COM_SMARTPTR_TYPEDEF(_dispProjectsEvents, __uuidof(_dispProjectsEvents)); + _COM_SMARTPTR_TYPEDEF(_MiscSlnFilesEventsRoot, __uuidof(_MiscSlnFilesEventsRoot)); + _COM_SMARTPTR_TYPEDEF(_CommandBarControlEvents, __uuidof(_CommandBarControlEvents)); + _COM_SMARTPTR_TYPEDEF(_dispCommandBarControlEvents, __uuidof(_dispCommandBarControlEvents)); + _COM_SMARTPTR_TYPEDEF(_OutputWindowEventsRoot, __uuidof(_OutputWindowEventsRoot)); + _COM_SMARTPTR_TYPEDEF(_TaskListEventsRoot, __uuidof(_TaskListEventsRoot)); + _COM_SMARTPTR_TYPEDEF(IDTToolsOptionsPage, __uuidof(IDTToolsOptionsPage)); + _COM_SMARTPTR_TYPEDEF(_EnvironmentWebBrowser, __uuidof(_EnvironmentWebBrowser)); + _COM_SMARTPTR_TYPEDEF(_EnvironmentHelp, __uuidof(_EnvironmentHelp)); + _COM_SMARTPTR_TYPEDEF(ColorableItems, __uuidof(ColorableItems)); + _COM_SMARTPTR_TYPEDEF(FontsAndColorsItems, __uuidof(FontsAndColorsItems)); + _COM_SMARTPTR_TYPEDEF(_FontsAndColors, __uuidof(_FontsAndColors)); + _COM_SMARTPTR_TYPEDEF(_EnvironmentGeneral, __uuidof(_EnvironmentGeneral)); + _COM_SMARTPTR_TYPEDEF(_EnvironmentFontsAndColors, __uuidof(_EnvironmentFontsAndColors)); + _COM_SMARTPTR_TYPEDEF(_EnvironmentProjectsAndSolution, __uuidof(_EnvironmentProjectsAndSolution)); + _COM_SMARTPTR_TYPEDEF(_EnvironmentDocuments, __uuidof(_EnvironmentDocuments)); + _COM_SMARTPTR_TYPEDEF(_EnvironmentTaskList, __uuidof(_EnvironmentTaskList)); + _COM_SMARTPTR_TYPEDEF(_EnvironmentKeyboard, __uuidof(_EnvironmentKeyboard)); + _COM_SMARTPTR_TYPEDEF(IExtensibleObject, __uuidof(IExtensibleObject)); + _COM_SMARTPTR_TYPEDEF(IVsTextEditGeneral, __uuidof(IVsTextEditGeneral)); + _COM_SMARTPTR_TYPEDEF(IVsTextEditPerLanguage, __uuidof(IVsTextEditPerLanguage)); + _COM_SMARTPTR_TYPEDEF(IVsTextEditFonts, __uuidof(IVsTextEditFonts)); + _COM_SMARTPTR_TYPEDEF(_DTE, __uuidof(_DTE)); + _COM_SMARTPTR_TYPEDEF(Windows, __uuidof(Windows)); + _COM_SMARTPTR_TYPEDEF(Window, __uuidof(Window)); + _COM_SMARTPTR_TYPEDEF(LinkedWindows, __uuidof(LinkedWindows)); + _COM_SMARTPTR_TYPEDEF(TextBuffer, __uuidof(TextBuffer)); + _COM_SMARTPTR_TYPEDEF(_WindowEventsRoot, __uuidof(_WindowEventsRoot)); + _COM_SMARTPTR_TYPEDEF(HTMLWindow, __uuidof(HTMLWindow)); + _COM_SMARTPTR_TYPEDEF(ProjectItem, __uuidof(ProjectItem)); + _COM_SMARTPTR_TYPEDEF(ItemOperations, __uuidof(ItemOperations)); + _COM_SMARTPTR_TYPEDEF(ProjectItems, __uuidof(ProjectItems)); + _COM_SMARTPTR_TYPEDEF(Project, __uuidof(Project)); + _COM_SMARTPTR_TYPEDEF(Projects, __uuidof(Projects)); + _COM_SMARTPTR_TYPEDEF(Properties, __uuidof(Properties)); + _COM_SMARTPTR_TYPEDEF(Property, __uuidof(Property)); + _COM_SMARTPTR_TYPEDEF(ConfigurationManager, __uuidof(ConfigurationManager)); + _COM_SMARTPTR_TYPEDEF(Configuration, __uuidof(Configuration)); + _COM_SMARTPTR_TYPEDEF(Configurations, __uuidof(Configurations)); + _COM_SMARTPTR_TYPEDEF(OutputGroups, __uuidof(OutputGroups)); + _COM_SMARTPTR_TYPEDEF(OutputGroup, __uuidof(OutputGroup)); + _COM_SMARTPTR_TYPEDEF(CodeModel, __uuidof(CodeModel)); + _COM_SMARTPTR_TYPEDEF(CodeElements, __uuidof(CodeElements)); + _COM_SMARTPTR_TYPEDEF(CodeElement, __uuidof(CodeElement)); + _COM_SMARTPTR_TYPEDEF(TextPoint, __uuidof(TextPoint)); + _COM_SMARTPTR_TYPEDEF(VirtualPoint, __uuidof(VirtualPoint)); + _COM_SMARTPTR_TYPEDEF(CodeAttribute, __uuidof(CodeAttribute)); + _COM_SMARTPTR_TYPEDEF(TextDocument, __uuidof(TextDocument)); + _COM_SMARTPTR_TYPEDEF(CommandWindow, __uuidof(CommandWindow)); + _COM_SMARTPTR_TYPEDEF(_TextEditorEventsRoot, __uuidof(_TextEditorEventsRoot)); + _COM_SMARTPTR_TYPEDEF(Document, __uuidof(Document)); + _COM_SMARTPTR_TYPEDEF(Documents, __uuidof(Documents)); + _COM_SMARTPTR_TYPEDEF(Events, __uuidof(Events)); + _COM_SMARTPTR_TYPEDEF(IVsExtensibility, __uuidof(IVsExtensibility)); + _COM_SMARTPTR_TYPEDEF(_DocumentEventsRoot, __uuidof(_DocumentEventsRoot)); + _COM_SMARTPTR_TYPEDEF(TextSelection, __uuidof(TextSelection)); + _COM_SMARTPTR_TYPEDEF(TextRanges, __uuidof(TextRanges)); + _COM_SMARTPTR_TYPEDEF(EditPoint, __uuidof(EditPoint)); + _COM_SMARTPTR_TYPEDEF(TextRange, __uuidof(TextRange)); + _COM_SMARTPTR_TYPEDEF(TextPane, __uuidof(TextPane)); + _COM_SMARTPTR_TYPEDEF(TextPanes, __uuidof(TextPanes)); + _COM_SMARTPTR_TYPEDEF(TextWindow, __uuidof(TextWindow)); + _COM_SMARTPTR_TYPEDEF(CodeType, __uuidof(CodeType)); + _COM_SMARTPTR_TYPEDEF(CodeTypeRef, __uuidof(CodeTypeRef)); + _COM_SMARTPTR_TYPEDEF(CodeParameter, __uuidof(CodeParameter)); + _COM_SMARTPTR_TYPEDEF(CodeFunction, __uuidof(CodeFunction)); + _COM_SMARTPTR_TYPEDEF(CodeVariable, __uuidof(CodeVariable)); + _COM_SMARTPTR_TYPEDEF(CodeNamespace, __uuidof(CodeNamespace)); + _COM_SMARTPTR_TYPEDEF(CodeEnum, __uuidof(CodeEnum)); + _COM_SMARTPTR_TYPEDEF(CodeClass, __uuidof(CodeClass)); + _COM_SMARTPTR_TYPEDEF(CodeProperty, __uuidof(CodeProperty)); + _COM_SMARTPTR_TYPEDEF(CodeInterface, __uuidof(CodeInterface)); + _COM_SMARTPTR_TYPEDEF(CodeDelegate, __uuidof(CodeDelegate)); + _COM_SMARTPTR_TYPEDEF(CodeStruct, __uuidof(CodeStruct)); + _COM_SMARTPTR_TYPEDEF(FileCodeModel, __uuidof(FileCodeModel)); + _COM_SMARTPTR_TYPEDEF(ContextAttributes, __uuidof(ContextAttributes)); + _COM_SMARTPTR_TYPEDEF(ContextAttribute, __uuidof(ContextAttribute)); + _COM_SMARTPTR_TYPEDEF(AddIn, __uuidof(AddIn)); + _COM_SMARTPTR_TYPEDEF(AddIns, __uuidof(AddIns)); + _COM_SMARTPTR_TYPEDEF(OutputWindowPane, __uuidof(OutputWindowPane)); + _COM_SMARTPTR_TYPEDEF(OutputWindowPanes, __uuidof(OutputWindowPanes)); + _COM_SMARTPTR_TYPEDEF(OutputWindow, __uuidof(OutputWindow)); + _COM_SMARTPTR_TYPEDEF(TaskItem, __uuidof(TaskItem)); + _COM_SMARTPTR_TYPEDEF(TaskItems, __uuidof(TaskItems)); + _COM_SMARTPTR_TYPEDEF(TaskList, __uuidof(TaskList)); + _COM_SMARTPTR_TYPEDEF(Process, __uuidof(Process)); + _COM_SMARTPTR_TYPEDEF(Programs, __uuidof(Programs)); + _COM_SMARTPTR_TYPEDEF(Program, __uuidof(Program)); + _COM_SMARTPTR_TYPEDEF(Threads, __uuidof(Threads)); + _COM_SMARTPTR_TYPEDEF(Thread, __uuidof(Thread)); + _COM_SMARTPTR_TYPEDEF(StackFrames, __uuidof(StackFrames)); + _COM_SMARTPTR_TYPEDEF(StackFrame, __uuidof(StackFrame)); + _COM_SMARTPTR_TYPEDEF(Expressions, __uuidof(Expressions)); + _COM_SMARTPTR_TYPEDEF(Expression, __uuidof(Expression)); + _COM_SMARTPTR_TYPEDEF(Debugger, __uuidof(Debugger)); + _COM_SMARTPTR_TYPEDEF(Processes, __uuidof(Processes)); + _COM_SMARTPTR_TYPEDEF(Breakpoints, __uuidof(Breakpoints)); + _COM_SMARTPTR_TYPEDEF(Breakpoint, __uuidof(Breakpoint)); + _COM_SMARTPTR_TYPEDEF(Languages, __uuidof(Languages)); + _COM_SMARTPTR_TYPEDEF(Language, __uuidof(Language)); + _COM_SMARTPTR_TYPEDEF(_Solution, __uuidof(_Solution)); + _COM_SMARTPTR_TYPEDEF(SolutionBuild, __uuidof(SolutionBuild)); + _COM_SMARTPTR_TYPEDEF(SolutionConfiguration, __uuidof(SolutionConfiguration)); + _COM_SMARTPTR_TYPEDEF(SolutionConfigurations, __uuidof(SolutionConfigurations)); + _COM_SMARTPTR_TYPEDEF(SolutionContexts, __uuidof(SolutionContexts)); + _COM_SMARTPTR_TYPEDEF(SolutionContext, __uuidof(SolutionContext)); + _COM_SMARTPTR_TYPEDEF(BuildDependencies, __uuidof(BuildDependencies)); + _COM_SMARTPTR_TYPEDEF(BuildDependency, __uuidof(BuildDependency)); + _COM_SMARTPTR_TYPEDEF(Commands, __uuidof(Commands)); + _COM_SMARTPTR_TYPEDEF(Command, __uuidof(Command)); + _COM_SMARTPTR_TYPEDEF(SelectedItems, __uuidof(SelectedItems)); + _COM_SMARTPTR_TYPEDEF(SelectedItem, __uuidof(SelectedItem)); + _COM_SMARTPTR_TYPEDEF(SelectionContainer, __uuidof(SelectionContainer)); + _COM_SMARTPTR_TYPEDEF(WindowConfigurations, __uuidof(WindowConfigurations)); + _COM_SMARTPTR_TYPEDEF(WindowConfiguration, __uuidof(WindowConfiguration)); + _COM_SMARTPTR_TYPEDEF(ToolBox, __uuidof(ToolBox)); + _COM_SMARTPTR_TYPEDEF(ToolBoxTab, __uuidof(ToolBoxTab)); + _COM_SMARTPTR_TYPEDEF(ToolBoxTabs, __uuidof(ToolBoxTabs)); + _COM_SMARTPTR_TYPEDEF(ToolBoxItems, __uuidof(ToolBoxItems)); + _COM_SMARTPTR_TYPEDEF(ToolBoxItem, __uuidof(ToolBoxItem)); + _COM_SMARTPTR_TYPEDEF(UIHierarchyItem, __uuidof(UIHierarchyItem)); + _COM_SMARTPTR_TYPEDEF(UIHierarchyItems, __uuidof(UIHierarchyItems)); + _COM_SMARTPTR_TYPEDEF(UIHierarchy, __uuidof(UIHierarchy)); + + // + // Type library items + // + + enum __declspec(uuid("cd678662-7939-48a0-bf1d-fa1bed56c130")) + vsWindowState + { + vsWindowStateNormal = 0, + vsWindowStateMinimize = 1, + vsWindowStateMaximize = 2 + }; + + enum __declspec(uuid("705cd8a9-d29b-11d2-aabd-00c04f688dde")) + vsWindowType + { + vsWindowTypeCodeWindow = 0, + vsWindowTypeDesigner = 1, + vsWindowTypeBrowser = 2, + vsWindowTypeWatch = 3, + vsWindowTypeLocals = 4, + vsWindowTypeImmediate = 5, + vsWindowTypeSolutionExplorer = 6, + vsWindowTypeProperties = 7, + vsWindowTypeFind = 8, + vsWindowTypeFindReplace = 9, + vsWindowTypeToolbox = 10, + vsWindowTypeLinkedWindowFrame = 11, + vsWindowTypeMainWindow = 12, + vsWindowTypePreview = 13, + vsWindowTypeColorPalette = 14, + vsWindowTypeToolWindow = 15, + vsWindowTypeDocument = 16, + vsWindowTypeOutput = 17, + vsWindowTypeTaskList = 18, + vsWindowTypeAutos = 19, + vsWindowTypeCallStack = 20, + vsWindowTypeThreads = 21, + vsWindowTypeDocumentOutline = 22, + vsWindowTypeRunningDocuments = 23 + }; + + struct __declspec(uuid("3c9cfe1e-389f-4118-9fad-365385190329")) + DTE; + // [ default ] interface _DTE + + enum __declspec(uuid("612256bd-7ba2-45c4-b60f-7b2ae42f96c3")) + vsConfigurationType + { + vsConfigurationTypeProject = 1, + vsConfigurationTypeProjectItem = 2 + }; + + struct __declspec(uuid("e68a3e0e-b435-4dde-86b7-f5adefc19df2")) + Globals : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * pDTE) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ IDispatch * * pDTE) = 0; + virtual HRESULT __stdcall get_VariableValue( + BSTR VariableName, + /*[out,retval]*/ VARIANT * pVal) = 0; + virtual HRESULT __stdcall put_VariableValue( + BSTR VariableName, + /*[in]*/ VARIANT pVal) = 0; + virtual HRESULT __stdcall put_VariablePersists( + BSTR VariableName, + /*[in]*/ VARIANT_BOOL pVal) = 0; + virtual HRESULT __stdcall get_VariablePersists( + BSTR VariableName, + /*[out,retval]*/ VARIANT_BOOL * pVal) = 0; + virtual HRESULT __stdcall get_VariableExists( + BSTR Name, + /*[out,retval]*/ VARIANT_BOOL * pVal) = 0; + virtual HRESULT __stdcall get_VariableNames( + /*[out,retval]*/ VARIANT * Names) = 0; + }; + + enum vsCMElement + { + vsCMElementOther = 0, + vsCMElementClass = 1, + vsCMElementFunction = 2, + vsCMElementVariable = 3, + vsCMElementProperty = 4, + vsCMElementNamespace = 5, + vsCMElementParameter = 6, + vsCMElementAttribute = 7, + vsCMElementInterface = 8, + vsCMElementDelegate = 9, + vsCMElementEnum = 10, + vsCMElementStruct = 11, + vsCMElementUnion = 12, + vsCMElementLocalDeclStmt = 13, + vsCMElementFunctionInvokeStmt = 14, + vsCMElementPropertySetStmt = 15, + vsCMElementAssignmentStmt = 16, + vsCMElementInheritsStmt = 17, + vsCMElementImplementsStmt = 18, + vsCMElementOptionStmt = 19, + vsCMElementVBAttributeStmt = 20, + vsCMElementVBAttributeGroup = 21, + vsCMElementEventsDeclaration = 22, + vsCMElementUDTDecl = 23, + vsCMElementDeclareDecl = 24, + vsCMElementDefineStmt = 25, + vsCMElementTypeDef = 26, + vsCMElementIncludeStmt = 27, + vsCMElementUsingStmt = 28, + vsCMElementMacro = 29, + vsCMElementMap = 30, + vsCMElementIDLImport = 31, + vsCMElementIDLImportLib = 32, + vsCMElementIDLCoClass = 33, + vsCMElementIDLLibrary = 34, + vsCMElementImportStmt = 35, + vsCMElementMapEntry = 36, + vsCMElementVCBase = 37, + vsCMElementEvent = 38, + vsCMElementModule = 39 + }; + + enum vsCMInfoLocation + { + vsCMInfoLocationProject = 1, + vsCMInfoLocationExternal = 2, + vsCMInfoLocationNone = 4, + vsCMInfoLocationVirtual = 8 + }; + + enum __declspec(uuid("aae3fae8-8afc-11d2-adee-00c04f7971c3")) + vsSaveChanges + { + vsSaveChangesYes = 1, + vsSaveChangesNo = 2, + vsSaveChangesPrompt = 3 + }; + + enum __declspec(uuid("8901ff7a-e6e8-4154-a505-135ee434817e")) + vsSaveStatus + { + vsSaveCancelled = 2, + vsSaveSucceeded = 1 + }; + + enum __declspec(uuid("98a2f403-007b-41f8-9a18-87addef1760f")) + vsCaseOptions + { + vsCaseOptionsLowercase = 1, + vsCaseOptionsUppercase = 2, + vsCaseOptionsCapitalize = 3 + }; + + enum __declspec(uuid("bbdfcfe4-4c68-4736-b991-f85fa955d585")) + vsWhitespaceOptions + { + vsWhitespaceOptionsHorizontal = 0, + vsWhitespaceOptionsVertical = 1 + }; + + enum __declspec(uuid("f05ea427-01ba-46dc-8392-fb4aa7e5eb3a")) + vsStartOfLineOptions + { + vsStartOfLineOptionsFirstColumn = 0, + vsStartOfLineOptionsFirstText = 1 + }; + + enum __declspec(uuid("b26ac3c2-3981-4a2e-9d6f-559b41cd1cd2")) + vsPaneShowHow + { + vsPaneShowCentered = 0, + vsPaneShowTop = 1, + vsPaneShowAsIs = 2 + }; + + enum __declspec(uuid("f3128012-b41f-46ec-8794-f716db9697d0")) + vsSelectionMode + { + vsSelectionModeStream = 0, + vsSelectionModeBox = 1 + }; + + enum vsCMPart + { + vsCMPartName = 1, + vsCMPartAttributes = 2, + vsCMPartHeader = 4, + vsCMPartWhole = 8, + vsCMPartBody = 16, + vsCMPartNavigate = 32, + vsCMPartAttributesWithDelimiter = 68, + vsCMPartBodyWithDelimiter = 80, + vsCMPartHeaderWithAttributes = 6, + vsCMPartWholeWithAttributes = 10 + }; + + enum vsCMAccess + { + vsCMAccessPublic = 1, + vsCMAccessPrivate = 2, + vsCMAccessProject = 4, + vsCMAccessProtected = 8, + vsCMAccessDefault = 32, + vsCMAccessAssemblyOrFamily = 64, + vsCMAccessWithEvents = 128, + vsCMAccessProjectOrProtected = 12 + }; + + enum vsCMFunction + { + vsCMFunctionOther = 0, + vsCMFunctionConstructor = 1, + vsCMFunctionPropertyGet = 2, + vsCMFunctionPropertyLet = 4, + vsCMFunctionPropertySet = 8, + vsCMFunctionPutRef = 16, + vsCMFunctionPropertyAssign = 32, + vsCMFunctionSub = 64, + vsCMFunctionFunction = 128, + vsCMFunctionTopLevel = 256, + vsCMFunctionDestructor = 512, + vsCMFunctionOperator = 1024, + vsCMFunctionVirtual = 2048, + vsCMFunctionPure = 4096, + vsCMFunctionConstant = 8192, + vsCMFunctionShared = 16384, + vsCMFunctionInline = 32768, + vsCMFunctionComMethod = 65536 + }; + + enum vsCMTypeRef + { + vsCMTypeRefOther = 0, + vsCMTypeRefCodeType = 1, + vsCMTypeRefArray = 2, + vsCMTypeRefVoid = 3, + vsCMTypeRefPointer = 4, + vsCMTypeRefString = 5, + vsCMTypeRefObject = 6, + vsCMTypeRefByte = 7, + vsCMTypeRefChar = 8, + vsCMTypeRefShort = 9, + vsCMTypeRefInt = 10, + vsCMTypeRefLong = 11, + vsCMTypeRefFloat = 12, + vsCMTypeRefDouble = 13, + vsCMTypeRefDecimal = 14, + vsCMTypeRefBool = 15, + vsCMTypeRefVariant = 16 + }; + + enum __declspec(uuid("410202e1-b83a-41dd-aab0-8c0029fe9435")) + vsContextAttributeType + { + vsContextAttributeFilter = 1, + vsContextAttributeLookup = 2, + vsContextAttributeLookupF1 = 3 + }; + + enum __declspec(uuid("59286edc-d580-4e22-96c9-44d15b6148cc")) + vsContextAttributes + { + vsContextAttributesGlobal = 1, + vsContextAttributesWindow = 2, + vsContextAttributesHighPriority = 3 + }; + + enum __declspec(uuid("539f9c17-db5f-421d-b02b-07bcf9faa92f")) + vsLinkedWindowType + { + vsLinkedWindowTypeDocked = 0, + vsLinkedWindowTypeVertical = 2, + vsLinkedWindowTypeHorizontal = 3, + vsLinkedWindowTypeTabbed = 1 + }; + + struct __declspec(uuid("1ded92b5-9a46-4b29-93ef-b5e07016659e")) + CommandEvents; + // [ default ] interface _CommandEvents + // [ default, source ] dispinterface _dispCommandEvents + + struct __declspec(uuid("a79fc678-0d0a-496a-b9dc-0d5b9e1ca9fc")) + _CommandEvents : IDispatch + {}; + + struct __declspec(uuid("ff2d5c12-feea-11d0-bbc8-00a0c90f2744")) + _dispCommandEvents : IDispatch + {}; + + struct __declspec(uuid("af37511e-9e9d-4234-a5a1-7584d290e061")) + SelectionEvents; + // [ default ] interface _SelectionEvents + // [ default, source ] dispinterface _dispSelectionEvents + + struct __declspec(uuid("eb6783db-1819-496d-84a4-3cff883010f6")) + _SelectionEvents : IDispatch + {}; + + struct __declspec(uuid("deeb28b3-23e6-11d1-ae5c-00a0c90f26f4")) + _dispSelectionEvents : IDispatch + {}; + + struct __declspec(uuid("88ac98c7-b38c-404b-bd86-d2a4f2e89dca")) + SolutionEvents; + // [ default ] interface _SolutionEvents + // [ default, source ] dispinterface _dispSolutionEvents + + struct __declspec(uuid("bf8bbf37-5415-46a9-940d-594cad9dec26")) + _SolutionEvents : IDispatch + {}; + + struct __declspec(uuid("fbcff1c2-261c-11d1-ae5e-00a0c90f26f4")) + _dispSolutionEvents : IDispatch + {}; + + struct __declspec(uuid("d83d60e3-229f-4660-8dd0-28b629eedcda")) + BuildEvents; + // [ default ] interface _BuildEvents + // [ default, source ] dispinterface _dispBuildEvents + + struct __declspec(uuid("794a2ba5-ffa6-4fc5-bf13-957b2c22edd7")) + _BuildEvents : IDispatch + {}; + + struct __declspec(uuid("1926364e-6b90-46cb-a44d-8a80fb11acd9")) + _dispBuildEvents : IDispatch + {}; + + enum __declspec(uuid("fa7fa701-efad-4895-a95a-d4ecb383bf7d")) + vsBuildScope + { + vsBuildScopeSolution = 1, + vsBuildScopeBatch = 2, + vsBuildScopeProject = 3 + }; + + enum __declspec(uuid("fa7fa702-efad-4895-a95a-d4ecb383bf7d")) + vsBuildAction + { + vsBuildActionBuild = 1, + vsBuildActionRebuildAll = 2, + vsBuildActionClean = 3, + vsBuildActionDeploy = 4 + }; + + struct __declspec(uuid("2e260fd4-c130-4e6d-8ebc-4a3bfd188181")) + WindowEvents; + // [ default ] interface _WindowEvents + // [ default, source ] dispinterface _dispWindowEvents + + struct __declspec(uuid("0d3a23a8-67bb-11d2-97c1-00c04fb6c6ff")) + _WindowEvents : IDispatch + {}; + + struct __declspec(uuid("0d3a23a9-67bb-11d2-97c1-00c04fb6c6ff")) + _dispWindowEvents : IDispatch + {}; + + struct __declspec(uuid("3760037f-b012-44f8-9c23-3609d7a16def")) + OutputWindowEvents; + // [ default ] interface _OutputWindowEvents + // [ default, source ] dispinterface _dispOutputWindowEvents + + struct __declspec(uuid("0a3546a8-6840-11d2-97c1-00c04fb6c6ff")) + _OutputWindowEvents : IDispatch + {}; + + struct __declspec(uuid("0d3a23af-67bb-11d2-97c1-00c04fb6c6ff")) + _dispOutputWindowEvents : IDispatch + {}; + + enum __declspec(uuid("36b56de8-5a17-11d1-b2b6-00c04fb6c6ff")) + vsTaskPriority + { + vsTaskPriorityLow = 1, + vsTaskPriorityMedium = 2, + vsTaskPriorityHigh = 3 + }; + + enum __declspec(uuid("195dab2e-4854-11d2-8820-00c04fb6c6ff")) + vsTaskIcon + { + vsTaskIconNone = 0, + vsTaskIconCompile = 1, + vsTaskIconSquiggle = 2, + vsTaskIconComment = 3, + vsTaskIconShortcut = 4, + vsTaskIconUser = 5 + }; + + struct __declspec(uuid("811322bc-042d-4828-bff2-640ef8b7209f")) + FindEvents; + // [ default ] interface _FindEvents + // [ default, source ] dispinterface _dispFindEvents + + struct __declspec(uuid("c5331acd-c5d5-11d2-8598-006097c68e81")) + _FindEvents : IDispatch + {}; + + struct __declspec(uuid("c5331ace-c5d5-11d2-8598-006097c68e81")) + _dispFindEvents : IDispatch + {}; + + enum __declspec(uuid("6fa137be-32a8-4f54-8099-60bb955097a3")) + vsFindResult + { + vsFindResultNotFound = 0, + vsFindResultFound = 1, + vsFindResultReplaceAndNotFound = 2, + vsFindResultReplaceAndFound = 3, + vsFindResultReplaced = 4, + vsFindResultPending = 5, + vsFindResultError = 6 + }; + + struct __declspec(uuid("29617acd-7859-4328-be09-298f91f48196")) + TaskListEvents; + // [ default ] interface _TaskListEvents + // [ default, source ] dispinterface _dispTaskListEvents + + struct __declspec(uuid("1125c422-49bd-11d2-8823-00c04fb6c6ff")) + _TaskListEvents : IDispatch + {}; + + struct __declspec(uuid("1125c423-49bd-11d2-8823-00c04fb6c6ff")) + _dispTaskListEvents : IDispatch + {}; + + enum __declspec(uuid("9848c17e-6aa5-11d2-97c3-00c04fb6c6ff")) + vsTaskListColumn + { + vsTaskListColumnPriority = 1, + vsTaskListColumnGlyph = 2, + vsTaskListColumnCheck = 4, + vsTaskListColumnDescription = 8, + vsTaskListColumnFile = 16, + vsTaskListColumnLine = 32 + }; + + struct __declspec(uuid("c6304bab-6765-4c63-9017-4940aeb6f207")) + DTEEvents; + // [ default ] interface _DTEEvents + // [ default, source ] dispinterface _dispDTEEvents + + struct __declspec(uuid("fa1bb6d7-ca83-11d2-aab2-00c04f688dde")) + _DTEEvents : IDispatch + {}; + + struct __declspec(uuid("b50c9708-c909-4b87-a03d-af6cc4bfb422")) + _dispDTEEvents : IDispatch + {}; + + enum __declspec(uuid("b638b3e3-c98b-4f59-9d05-105a620529f9")) + vsIDEMode + { + vsIDEModeDesign = 1, + vsIDEModeDebug = 2 + }; + + struct __declspec(uuid("dc5437f7-f114-11d2-aacf-00c04f688dde")) + DocumentEvents; + // [ default ] interface _DocumentEvents + // [ default, source ] dispinterface _dispDocumentEvents + + struct __declspec(uuid("dc5437f5-f114-11d2-aacf-00c04f688dde")) + _DocumentEvents : IDispatch + {}; + + struct __declspec(uuid("dc5437f6-f114-11d2-aacf-00c04f688dde")) + _dispDocumentEvents : IDispatch + {}; + + struct __declspec(uuid("de6c1098-93ca-4f49-bef0-262a13ca1176")) + ProjectItemsEvents; + // [ default ] interface _ProjectItemsEvents + // [ default, source ] dispinterface _dispProjectItemsEvents + + struct __declspec(uuid("22800963-2811-410d-bf87-a7808eac977d")) + _ProjectItemsEvents : IDispatch + {}; + + struct __declspec(uuid("6962753f-efd5-41c5-b083-d70687166aeb")) + _dispProjectItemsEvents : IDispatch + {}; + + struct __declspec(uuid("0c763210-0fbb-11d3-b880-00c04f79e479")) + DebuggerEvents; + // [ default ] interface _DebuggerEvents + // [ default, source ] dispinterface _dispDebuggerEvents + + struct __declspec(uuid("d4eae958-0fba-11d3-b880-00c04f79e479")) + _DebuggerEvents : IDispatch + {}; + + struct __declspec(uuid("46209330-0fba-11d3-b880-00c04f79e479")) + _dispDebuggerEvents : IDispatch + {}; + + enum __declspec(uuid("4106c580-c146-11d2-8ad1-00c04f79e479")) + dbgEventReason + { + dbgEventReasonNone = 1, + dbgEventReasonGo = 2, + dbgEventReasonAttachProgram = 3, + dbgEventReasonDetachProgram = 4, + dbgEventReasonLaunchProgram = 5, + dbgEventReasonEndProgram = 6, + dbgEventReasonStopDebugging = 7, + dbgEventReasonStep = 8, + dbgEventReasonBreakpoint = 9, + dbgEventReasonExceptionThrown = 10, + dbgEventReasonExceptionNotHandled = 11, + dbgEventReasonUserBreak = 12, + dbgEventReasonContextSwitch = 13 + }; + + enum __declspec(uuid("77940e85-bce0-443d-8b77-f5bd841a211e")) + dbgExecutionAction + { + dbgExecutionActionDefault = 1, + dbgExecutionActionGo = 2, + dbgExecutionActionStopDebugging = 3, + dbgExecutionActionStepInto = 4, + dbgExecutionActionStepOut = 5, + dbgExecutionActionStepOver = 6, + dbgExecutionActionRunToCursor = 7 + }; + + enum __declspec(uuid("ed2fbdd2-1eb1-11d3-b888-00c04f79e479")) + dbgExceptionAction + { + dbgExceptionActionDefault = 1, + dbgExceptionActionIgnore = 2, + dbgExceptionActionBreak = 3, + dbgExceptionActionContinue = 4 + }; + + enum __declspec(uuid("75607dde-2b43-11d3-b88b-00c04f79e479")) + dbgBreakpointType + { + dbgBreakpointTypePending = 1, + dbgBreakpointTypeBound = 2 + }; + + enum __declspec(uuid("229c054c-c146-11d2-8ad1-00c04f79e479")) + dbgBreakpointLocationType + { + dbgBreakpointLocationTypeNone = 1, + dbgBreakpointLocationTypeFunction = 2, + dbgBreakpointLocationTypeFile = 3, + dbgBreakpointLocationTypeData = 4, + dbgBreakpointLocationTypeAddress = 5 + }; + + enum __declspec(uuid("2a594772-c146-11d2-8ad1-00c04f79e479")) + dbgBreakpointConditionType + { + dbgBreakpointConditionTypeWhenTrue = 1, + dbgBreakpointConditionTypeWhenChanged = 2 + }; + + enum __declspec(uuid("3a3329ce-c146-11d2-8ad1-00c04f79e479")) + dbgHitCountType + { + dbgHitCountTypeNone = 1, + dbgHitCountTypeEqual = 2, + dbgHitCountTypeGreaterOrEqual = 3, + dbgHitCountTypeMultiple = 4 + }; + + enum __declspec(uuid("e940c60a-c68f-11d2-8ad6-00c04f79e479")) + dbgDebugMode + { + dbgDesignMode = 1, + dbgBreakMode = 2, + dbgRunMode = 3 + }; + + struct __declspec(uuid("adf22c37-0069-4adf-b12d-d8d47c38fe79")) + TextEditorEvents; + // [ default ] interface _TextEditorEvents + // [ default, source ] dispinterface _dispTextEditorEvents + + struct __declspec(uuid("23b7a868-6c89-436a-94fa-25d755456a77")) + _TextEditorEvents : IDispatch + {}; + + struct __declspec(uuid("2699dd44-c507-4da3-aa34-314a6c21dfe2")) + _dispTextEditorEvents : IDispatch + {}; + + enum __declspec(uuid("e0e643c3-5410-487a-b64e-2664a5c4ab50")) + vsDisplay + { + vsDisplayMDI = 1, + vsDisplayMDITabs = 2 + }; + + struct __declspec(uuid("b35caa8c-77de-4ab3-8e5a-f038e3fc6056")) + Solution; + // [ default ] interface _Solution + + enum __declspec(uuid("16386f0e-4ad2-41b8-8d6f-7ff230ae1d17")) + vsBuildState + { + vsBuildStateNotStarted = 1, + vsBuildStateInProgress = 2, + vsBuildStateDone = 3 + }; + + enum __declspec(uuid("79946991-1ae2-4d2d-9768-fd7801be7daa")) + vsCommandBarType + { + vsCommandBarTypePopup = 10, + vsCommandBarTypeToolbar = 23, + vsCommandBarTypeMenu = 24 + }; + + struct __declspec(uuid("c34301a1-3ef1-41d8-932a-fea4a8a8ce0c")) + StatusBar : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * pDTE) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct _DTE * * pDTE) = 0; + virtual HRESULT __stdcall Clear() = 0; + virtual HRESULT __stdcall Animate( + VARIANT_BOOL On, + VARIANT AnimationType) = 0; + virtual HRESULT __stdcall Progress( + VARIANT_BOOL InProgress, + /*[in]*/ BSTR Label, + /*[in]*/ long AmountCompleted, + /*[in]*/ long Total) = 0; + virtual HRESULT __stdcall SetXYWidthHeight( + long X, + long Y, + long Width, + long Height) = 0; + virtual HRESULT __stdcall SetLineColumnCharacter( + long Line, + long Column, + long Character) = 0; + virtual HRESULT __stdcall put_Text( + /*[in]*/ BSTR pTextc) = 0; + virtual HRESULT __stdcall get_Text( + /*[out,retval]*/ BSTR * pTextc) = 0; + virtual HRESULT __stdcall Highlight( + VARIANT_BOOL Highlight) = 0; + virtual HRESULT __stdcall ShowTextUpdates( + VARIANT_BOOL TextUpdates, + /*[out,retval]*/ VARIANT_BOOL * WillShowUpdates) = 0; + }; + + struct __declspec(uuid("e57c510b-968b-4a3c-a467-ee4013157dc9")) + IExtenderSite : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall NotifyDelete( + /*[in]*/ long Cookie) = 0; + virtual HRESULT __stdcall GetObject( + /*[in]*/ BSTR Name, + /*[out,retval]*/ IDispatch * * ppObject) = 0; + }; + + struct __declspec(uuid("4db06329-23f4-443b-9abd-9cf611e8ae07")) + IExtenderProvider : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall GetExtender( + /*[in]*/ BSTR ExtenderCATID, + /*[in]*/ BSTR ExtenderName, + /*[in]*/ IDispatch * ExtendeeObject, + /*[in]*/ struct IExtenderSite * ExtenderSite, + /*[in]*/ long Cookie, + /*[out,retval]*/ IDispatch * * Extender) = 0; + virtual HRESULT __stdcall CanExtend( + /*[in]*/ BSTR ExtenderCATID, + /*[in]*/ BSTR ExtenderName, + /*[in]*/ IDispatch * ExtendeeObject, + /*[out,retval]*/ VARIANT_BOOL * fRetval) = 0; + }; + + struct __declspec(uuid("f69b64a3-9017-4e48-9784-e152b51aa722")) + IExtenderProviderUnk : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall GetExtender( + /*[in]*/ BSTR ExtenderCATID, + /*[in]*/ BSTR ExtenderName, + /*[in]*/ IUnknown * ExtendeeObject, + /*[in]*/ struct IExtenderSite * ExtenderSite, + /*[in]*/ long Cookie, + /*[out,retval]*/ IDispatch * * Extender) = 0; + virtual HRESULT __stdcall CanExtend( + /*[in]*/ BSTR ExtenderCATID, + /*[in]*/ BSTR ExtenderName, + /*[in]*/ IUnknown * ExtendeeObject, + /*[out,retval]*/ VARIANT_BOOL * fRetval) = 0; + }; + + struct __declspec(uuid("8d0aa9cc-8465-42f3-ad6e-dfde28ccc75d")) + ObjectExtenders : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * lppaReturn) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct _DTE * * lppaReturn) = 0; + virtual HRESULT __stdcall RegisterExtenderProvider( + /*[in]*/ BSTR ExtenderCATID, + /*[in]*/ BSTR ExtenderName, + /*[in]*/ struct IExtenderProvider * ExtenderProvider, + /*[in]*/ BSTR LocalizedName, + /*[out,retval]*/ long * Cookie) = 0; + virtual HRESULT __stdcall UnregisterExtenderProvider( + /*[in]*/ long Cookie) = 0; + virtual HRESULT __stdcall GetExtender( + /*[in]*/ BSTR ExtenderCATID, + /*[in]*/ BSTR ExtenderName, + /*[in]*/ IUnknown * ExtendeeObject, + /*[out,retval]*/ IDispatch * * Extender) = 0; + virtual HRESULT __stdcall GetExtenderNames( + /*[in]*/ BSTR ExtenderCATID, + /*[in]*/ IUnknown * ExtendeeObject, + /*[out,retval]*/ VARIANT * ExtenderNames) = 0; + virtual HRESULT __stdcall GetContextualExtenderCATIDs( + /*[out,retval]*/ VARIANT * ExtenderCATIDs) = 0; + virtual HRESULT __stdcall GetLocalizedExtenderName( + /*[in]*/ BSTR ExtenderCATID, + /*[in]*/ BSTR ExtenderName, + /*[out,retval]*/ BSTR * pLocalizedName) = 0; + virtual HRESULT __stdcall RegisterExtenderProviderUnk( + /*[in]*/ BSTR ExtenderCATID, + /*[in]*/ BSTR ExtenderName, + /*[in]*/ struct IExtenderProviderUnk * ExtenderProvider, + /*[in]*/ BSTR LocalizedName, + /*[out,retval]*/ long * Cookie) = 0; + }; + + enum __declspec(uuid("9fb64132-726a-4262-829e-051c6ec7b24f")) + vsFindAction + { + vsFindActionFind = 1, + vsFindActionFindAll = 2, + vsFindActionReplace = 3, + vsFindActionReplaceAll = 4, + vsFindActionBookmarkAll = 5 + }; + + enum __declspec(uuid("530f2d0e-a5f9-4b7a-a379-0a3b99b5e66d")) + vsFindPatternSyntax + { + vsFindPatternSyntaxLiteral = 0, + vsFindPatternSyntaxRegExpr = 1, + vsFindPatternSyntaxWildcards = 2 + }; + + enum __declspec(uuid("481899fb-b657-4e45-8c00-0e051052bb13")) + vsFindTarget + { + vsFindTargetCurrentDocument = 1, + vsFindTargetCurrentDocumentSelection = 2, + vsFindTargetCurrentDocumentFunction = 3, + vsFindTargetOpenDocuments = 4, + vsFindTargetCurrentProject = 5, + vsFindTargetSolution = 6, + vsFindTargetFiles = 7 + }; + + enum __declspec(uuid("ea9142bf-b2af-48a7-b256-93ccd3350bd8")) + vsFindResultsLocation + { + vsFindResultsNone = 0, + vsFindResults1 = 1, + vsFindResults2 = 2 + }; + + struct __declspec(uuid("40d4b9b6-739b-4965-8d65-692aec692266")) + Find : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * lppaReturn) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct _DTE * * lppaReturn) = 0; + virtual HRESULT __stdcall get_Action( + /*[out,retval]*/ enum vsFindAction * pAction) = 0; + virtual HRESULT __stdcall put_Action( + /*[in]*/ enum vsFindAction pAction) = 0; + virtual HRESULT __stdcall get_FindWhat( + /*[out,retval]*/ BSTR * pFindWhat) = 0; + virtual HRESULT __stdcall put_FindWhat( + /*[in]*/ BSTR pFindWhat) = 0; + virtual HRESULT __stdcall get_MatchCase( + /*[out,retval]*/ VARIANT_BOOL * pMatchCase) = 0; + virtual HRESULT __stdcall put_MatchCase( + /*[in]*/ VARIANT_BOOL pMatchCase) = 0; + virtual HRESULT __stdcall get_MatchWholeWord( + /*[out,retval]*/ VARIANT_BOOL * pMatchWholeWord) = 0; + virtual HRESULT __stdcall put_MatchWholeWord( + /*[in]*/ VARIANT_BOOL pMatchWholeWord) = 0; + virtual HRESULT __stdcall get_MatchInHiddenText( + /*[out,retval]*/ VARIANT_BOOL * pMatchInHiddenText) = 0; + virtual HRESULT __stdcall put_MatchInHiddenText( + /*[in]*/ VARIANT_BOOL pMatchInHiddenText) = 0; + virtual HRESULT __stdcall get_Backwards( + /*[out,retval]*/ VARIANT_BOOL * pBackwards) = 0; + virtual HRESULT __stdcall put_Backwards( + /*[in]*/ VARIANT_BOOL pBackwards) = 0; + virtual HRESULT __stdcall get_SearchSubfolders( + /*[out,retval]*/ VARIANT_BOOL * pSearchSubfolders) = 0; + virtual HRESULT __stdcall put_SearchSubfolders( + /*[in]*/ VARIANT_BOOL pSearchSubfolders) = 0; + virtual HRESULT __stdcall get_KeepModifiedDocumentsOpen( + /*[out,retval]*/ VARIANT_BOOL * pKeepModifiedDocumentsOpen) = 0; + virtual HRESULT __stdcall put_KeepModifiedDocumentsOpen( + /*[in]*/ VARIANT_BOOL pKeepModifiedDocumentsOpen) = 0; + virtual HRESULT __stdcall get_PatternSyntax( + /*[out,retval]*/ enum vsFindPatternSyntax * pPatternSyntax) = 0; + virtual HRESULT __stdcall put_PatternSyntax( + /*[in]*/ enum vsFindPatternSyntax pPatternSyntax) = 0; + virtual HRESULT __stdcall get_ReplaceWith( + /*[out,retval]*/ BSTR * pReplaceWith) = 0; + virtual HRESULT __stdcall put_ReplaceWith( + /*[in]*/ BSTR pReplaceWith) = 0; + virtual HRESULT __stdcall get_Target( + /*[out,retval]*/ enum vsFindTarget * pTarget) = 0; + virtual HRESULT __stdcall put_Target( + /*[in]*/ enum vsFindTarget pTarget) = 0; + virtual HRESULT __stdcall get_SearchPath( + /*[out,retval]*/ BSTR * pSearchPath) = 0; + virtual HRESULT __stdcall put_SearchPath( + /*[in]*/ BSTR pSearchPath) = 0; + virtual HRESULT __stdcall get_FilesOfType( + /*[out,retval]*/ BSTR * pFilesOfType) = 0; + virtual HRESULT __stdcall put_FilesOfType( + /*[in]*/ BSTR pFilesOfType) = 0; + virtual HRESULT __stdcall get_ResultsLocation( + /*[out,retval]*/ enum vsFindResultsLocation * pResultsLocation) = 0; + virtual HRESULT __stdcall put_ResultsLocation( + /*[in]*/ enum vsFindResultsLocation pResultsLocation) = 0; + virtual HRESULT __stdcall Execute( + /*[out,retval]*/ enum vsFindResult * pResult) = 0; + virtual HRESULT __stdcall FindReplace( + /*[in]*/ enum vsFindAction Action, + /*[in]*/ BSTR FindWhat, + /*[in]*/ long vsFindOptionsValue, + /*[in]*/ BSTR ReplaceWith, + /*[in]*/ enum vsFindTarget Target, + /*[in]*/ BSTR SearchPath, + /*[in]*/ BSTR FilesOfType, + /*[in]*/ enum vsFindResultsLocation ResultsLocation, + /*[out,retval]*/ enum vsFindResult * pResult) = 0; + }; + + enum __declspec(uuid("d920605a-11dd-4a12-a8dc-10578bb08606")) + wizardResult + { + wizardResultSuccess = -1, + wizardResultFailure = 0, + wizardResultCancel = 1, + wizardResultBackOut = 2 + }; + + enum __declspec(uuid("b4cc3e73-0038-47e5-ba52-d1183f8fdbf0")) + vsNavigateOptions + { + vsNavigateOptionsDefault = 0, + vsNavigateOptionsNewWindow = 1 + }; + + enum __declspec(uuid("ca3ee5d0-6305-422f-a425-99737956088f")) + vsPromptResult + { + vsPromptResultYes = 1, + vsPromptResultNo = 2, + vsPromptResultCancelled = 3 + }; + + struct __declspec(uuid("d8dec44d-caf2-4b39-a539-b91ae921ba92")) + UndoContext : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * DTEObject) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct _DTE * * DTEObject) = 0; + virtual HRESULT __stdcall Open( + /*[in]*/ BSTR Name, + /*[in]*/ VARIANT_BOOL Strict) = 0; + virtual HRESULT __stdcall Close() = 0; + virtual HRESULT __stdcall SetAborted() = 0; + virtual HRESULT __stdcall get_IsStrict( + /*[out,retval]*/ VARIANT_BOOL * pIsStrict) = 0; + virtual HRESULT __stdcall get_IsAborted( + /*[out,retval]*/ VARIANT_BOOL * pIsAborted) = 0; + virtual HRESULT __stdcall get_IsOpen( + /*[out,retval]*/ VARIANT_BOOL * pIsOpen) = 0; + }; + + struct __declspec(uuid("f9f99155-6d4d-49b1-ad63-c78c3e8a5916")) + Macros : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * pDTE) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct _DTE * * pDTE) = 0; + virtual HRESULT __stdcall get_IsRecording( + /*[out,retval]*/ VARIANT_BOOL * vbIsRecording) = 0; + virtual HRESULT __stdcall EmitMacroCode( + BSTR Code) = 0; + virtual HRESULT __stdcall Pause() = 0; + virtual HRESULT __stdcall Resume() = 0; + }; + + struct __declspec(uuid("f1ddc2c2-df76-4ebb-9de8-48ad2557062c")) + SourceControl : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * ppDTEObject) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct _DTE * * ppDTEObject) = 0; + virtual HRESULT __stdcall IsItemUnderSCC( + /*[in]*/ BSTR ItemName, + /*[out,retval]*/ VARIANT_BOOL * pfControlled) = 0; + virtual HRESULT __stdcall IsItemCheckedOut( + /*[in]*/ BSTR ItemName, + /*[out,retval]*/ VARIANT_BOOL * pfCheckedOut) = 0; + virtual HRESULT __stdcall CheckOutItem( + /*[in]*/ BSTR ItemName, + /*[out,retval]*/ VARIANT_BOOL * pfCheckedOut) = 0; + virtual HRESULT __stdcall CheckOutItems( + /*[in]*/ SAFEARRAY * * ItemNames, + /*[out,retval]*/ VARIANT_BOOL * pfCheckedOut) = 0; + virtual HRESULT __stdcall ExcludeItem( + /*[in]*/ BSTR ProjectFile, + /*[in]*/ BSTR ItemName) = 0; + virtual HRESULT __stdcall ExcludeItems( + /*[in]*/ BSTR ProjectFile, + /*[in]*/ SAFEARRAY * * ItemNames) = 0; + }; + + struct __declspec(uuid("6659ed14-2ab6-47f3-a890-00c8aba43b84")) + ISupportVSProperties : IUnknown + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall NotifyPropertiesDelete() = 0; + }; + + enum __declspec(uuid("44df8fdc-7378-11d2-97ca-00c04fb6c6ff")) + vsToolBoxItemFormat + { + vsToolBoxItemFormatText = 1, + vsToolBoxItemFormatHTML = 2, + vsToolBoxItemFormatGUID = 4, + vsToolBoxItemFormatDotNETComponent = 8 + }; + + struct __declspec(uuid("eb5be8a7-e593-4de6-a923-c2afecb96336")) + IExtensibleObjectSite : IUnknown + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall NotifyDelete( + /*[in]*/ IUnknown * punkObj) = 0; + }; + + struct __declspec(uuid("8cc0cde1-c16a-4749-99af-6f7523c34a57")) + IVsProfferCommands : IUnknown + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall AddNamedCommand( + /*[in]*/ GUID * pguidPackage, + /*[in]*/ GUID * pguidCmdGroup, + /*[in]*/ LPWSTR pszCmdNameCanonical, + /*[out]*/ unsigned long * pdwCmdId, + /*[in]*/ LPWSTR pszCmdNameLocalized, + /*[in]*/ LPWSTR pszBtnText, + /*[in]*/ LPWSTR pszCmdTooltip, + /*[in]*/ LPWSTR pszSatelliteDLL, + /*[in]*/ unsigned long dwBitmapResourceId, + /*[in]*/ unsigned long dwBitmapImageIndex, + /*[in]*/ unsigned long dwCmdFlagsDefault, + /*[in]*/ unsigned long cUIContexts, + /*[in]*/ GUID * rgguidUIContexts) = 0; + virtual HRESULT __stdcall RemoveNamedCommand( + /*[in]*/ LPWSTR pszCmdNameCanonical) = 0; + virtual HRESULT __stdcall RenameNamedCommand( + /*[in]*/ LPWSTR pszCmdNameCanonical, + /*[in]*/ LPWSTR pszCmdNameCanonicalNew, + /*[in]*/ LPWSTR pszCmdNameLocalizedNew) = 0; + virtual HRESULT __stdcall AddCommandBarControl( + /*[in]*/ LPWSTR pszCmdNameCanonical, + /*[in]*/ IDispatch * pCmdBarParent, + /*[in]*/ unsigned long dwIndex, + /*[in]*/ unsigned long dwCmdType, + /*[out]*/ IDispatch * * ppCmdBarCtrl) = 0; + virtual HRESULT __stdcall RemoveCommandBarControl( + /*[in]*/ IDispatch * pCmdBarCtrl) = 0; + virtual HRESULT __stdcall AddCommandBar( + /*[in]*/ LPWSTR pszCmdBarName, + /*[in]*/ enum vsCommandBarType dwType, + /*[in]*/ IDispatch * pCmdBarParent, + /*[in]*/ unsigned long dwIndex, + /*[out]*/ IDispatch * * ppCmdBar) = 0; + virtual HRESULT __stdcall RemoveCommandBar( + /*[in]*/ IDispatch * pCmdBar) = 0; + virtual HRESULT __stdcall FindCommandBar( + /*[in]*/ void * pToolbarSet, + /*[in]*/ GUID * pguidCmdGroup, + /*[in]*/ unsigned long dwMenuId, + /*[out,retval]*/ IDispatch * * ppdispCmdBar) = 0; + }; + + enum __declspec(uuid("221ab797-408b-4d69-9dd1-c6f329189414")) + vsFilterProperties + { + vsFilterPropertiesNone = 0, + vsFilterPropertiesAll = 1, + vsFilterPropertiesSet = 2 + }; + + struct __declspec(uuid("aade1f59-6ace-43d1-8fca-42af3a5c4f3c")) + IFilterProperties : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall IsPropertyHidden( + /*[in]*/ BSTR PropertyName, + /*[out,retval]*/ enum vsFilterProperties * pRetval) = 0; + }; + + enum __declspec(uuid("28362492-b1e3-4998-94c6-0a2cdb5484ed")) + vsUISelectionType + { + vsUISelectionTypeSelect = 1, + vsUISelectionTypeToggle = 2, + vsUISelectionTypeExtend = 3, + vsUISelectionTypeSetCaret = 4 + }; + + struct __declspec(uuid("9ff3ddca-1795-4191-a5b1-02d1ae35d074")) + TextEditor : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_Application( + /*[out,retval]*/ struct _DTE * * ppApp) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct _DTE * * ppParent) = 0; + virtual HRESULT __stdcall get_Emulation( + /*[out,retval]*/ long * pEditorType) = 0; + virtual HRESULT __stdcall put_Emulation( + /*[in]*/ long pEditorType) = 0; + virtual HRESULT __stdcall get_Overtype( + /*[out,retval]*/ VARIANT_BOOL * pbOT) = 0; + virtual HRESULT __stdcall put_Overtype( + /*[in]*/ VARIANT_BOOL pbOT) = 0; + virtual HRESULT __stdcall get_VisibleWhitespace( + /*[out,retval]*/ VARIANT_BOOL * pbVW) = 0; + virtual HRESULT __stdcall put_VisibleWhitespace( + /*[in]*/ VARIANT_BOOL pbVW) = 0; + }; + const LPSTR vsCMLanguageVC = (char*) "{B5E9BD32-6D3E-4B5D-925E-8A43B79820B4}"; + const LPSTR vsCMLanguageVB = (char*) "{B5E9BD33-6D3E-4B5D-925E-8A43B79820B4}"; + const LPSTR vsCMLanguageCSharp = (char*) "{B5E9BD34-6D3E-4B5D-925E-8A43B79820B4}"; + const LPSTR vsCMLanguageIDL = (char*) "{B5E9BD35-6D3E-4B5D-925E-8A43B79820B4}"; + const LPSTR vsCMLanguageMC = (char*) "{B5E9BD36-6D3E-4B5D-925E-8A43B79820B4}"; + + enum __declspec(uuid("ed1a3f98-4477-11d3-89bf-00c04f688dde")) + vsCMPrototype + { + vsCMPrototypeFullname = 1, + vsCMPrototypeNoName = 2, + vsCMPrototypeClassName = 4, + vsCMPrototypeParamTypes = 8, + vsCMPrototypeParamNames = 16, + vsCMPrototypeParamDefaultValues = 32, + vsCMPrototypeUniqueSignature = 64, + vsCMPrototypeType = 128, + vsCMPrototypeInitExpression = 256 + }; + + struct __declspec(uuid("d4bb39fb-0f0e-11d3-b880-00c04f79e479")) + _DebuggerEventsRoot : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DebuggerEvents( + /*[out,retval]*/ IDispatch * * disp) = 0; + }; + + enum __declspec(uuid("178c767a-1963-4bc5-b3f2-e70f3eb441a8")) + vsNavigateBrowser + { + vsNavigateBrowserDefault = 0, + vsNavigateBrowserHelp = 1, + vsNavigateBrowserNewWindow = 2 + }; + + enum __declspec(uuid("947978f5-185b-4366-921e-a14c0ed46702")) + vsCommandDisabledFlags + { + vsCommandDisabledFlagsEnabled = 0, + vsCommandDisabledFlagsGrey = 16, + vsCommandDisabledFlagsHidden = 32 + }; + + enum __declspec(uuid("9e3c8489-ae44-4fcf-9697-cd3f312ba08c")) + vsInitializeMode + { + vsInitializeModeStartup = 0, + vsInitializeModeReset = 1 + }; + + struct __declspec(uuid("e914bbe1-03a4-11d1-bbcd-00a0c90f2744")) + IDTWizard : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall Execute( + /*[in]*/ IDispatch * Application, + /*[in]*/ long hwndOwner, + /*[in]*/ SAFEARRAY * * ContextParams, + /*[in]*/ SAFEARRAY * * CustomParams, + /*[in,out]*/ enum wizardResult * retval) = 0; + }; + + struct __declspec(uuid("e2cc506a-588b-4f65-a1f0-2244c060abcb")) + IVsGlobalsCallback : IUnknown + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall WriteVariablesToData( + /*[in]*/ LPWSTR pVariableName, + /*[in]*/ VARIANT * varData) = 0; + virtual HRESULT __stdcall ReadData( + /*[in]*/ struct Globals * pGlobals) = 0; + virtual HRESULT __stdcall ClearVariables() = 0; + virtual HRESULT __stdcall VariableChanged() = 0; + virtual HRESULT __stdcall CanModifySource() = 0; + virtual HRESULT __stdcall GetParent( + IDispatch * * ppOut) = 0; + }; + + struct __declspec(uuid("192ac688-e7c6-4f9d-8180-4b37efbf6f3a")) + IVsGlobals : IUnknown + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall Load() = 0; + virtual HRESULT __stdcall Save() = 0; + virtual HRESULT __stdcall Empty() = 0; + }; + + enum __declspec(uuid("d9e97957-b425-4cd6-bb74-9e6f232a342a")) + vsCommandStatusTextWanted + { + vsCommandStatusTextWantedNone = 0, + vsCommandStatusTextWantedName = 1, + vsCommandStatusTextWantedStatus = 2 + }; + + enum __declspec(uuid("e0ace2e3-49c1-4aa3-ac03-a2877a93d77f")) + vsCommandStatus + { + vsCommandStatusUnsupported = 0, + vsCommandStatusSupported = 1, + vsCommandStatusEnabled = 2, + vsCommandStatusLatched = 4, + vsCommandStatusNinched = 8, + vsCommandStatusInvisible = 16 + }; + + enum __declspec(uuid("3c537e1a-39b8-4fda-9f22-93d8c030865d")) + vsCommandExecOption + { + vsCommandExecOptionDoDefault = 0, + vsCommandExecOptionPromptUser = 1, + vsCommandExecOptionDoPromptUser = 2, + vsCommandExecOptionShowHelp = 3 + }; + + struct __declspec(uuid("7ef39a3e-590d-4879-88d4-c9be5bcfd92e")) + IDTCommandTarget : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall QueryStatus( + /*[in]*/ BSTR CmdName, + /*[in]*/ enum vsCommandStatusTextWanted NeededText, + /*[in,out]*/ enum vsCommandStatus * StatusOption, + /*[in,out]*/ VARIANT * CommandText) = 0; + virtual HRESULT __stdcall Exec( + /*[in]*/ BSTR CmdName, + /*[in]*/ enum vsCommandExecOption ExecuteOption, + /*[in]*/ VARIANT * VariantIn, + /*[in,out]*/ VARIANT * VariantOut, + /*[in,out]*/ VARIANT_BOOL * Handled) = 0; + }; + + struct __declspec(uuid("85451f83-b5ca-437f-a619-0cb705707420")) + _ProjectsEvents : IDispatch + {}; + + struct __declspec(uuid("7f508d55-627f-4d7f-be0b-9e3d829ff0ed")) + _dispProjectsEvents : IDispatch + {}; + + struct __declspec(uuid("536a4be3-a376-408e-954c-471c779e216f")) + ProjectsEvents; + // [ default ] interface _ProjectsEvents + // [ default, source ] dispinterface _dispProjectsEvents + + struct __declspec(uuid("7658b944-f37b-11d2-aacf-00c04f688dde")) + _MiscSlnFilesEventsRoot : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_SolutionItemsEvents( + /*[out,retval]*/ IDispatch * * ppeNew) = 0; + virtual HRESULT __stdcall get_MiscFilesEvents( + /*[out,retval]*/ IDispatch * * ppeNew) = 0; + }; + + struct __declspec(uuid("9e66fe98-a1c6-421d-8c0c-6da4e652e770")) + _CommandBarControlEvents : IDispatch + {}; + + struct __declspec(uuid("987fb893-f96d-11d0-bbbb-00a0c90f2744")) + _dispCommandBarControlEvents : IDispatch + {}; + + struct __declspec(uuid("bfd4b2b2-9eec-4db8-aba0-ac316f4c7328")) + CommandBarEvents; + // [ default ] interface _CommandBarControlEvents + // [ default, source ] dispinterface _dispCommandBarControlEvents + + enum __declspec(uuid("3982fa28-7bcc-4f14-817c-93eeece8beee")) + vsBuildKind + { + vsBuildKindSolution = 0, + vsBuildKindProject = 1, + vsBuildKindProjectItem = 2 + }; + + enum __declspec(uuid("11f0cb7f-4f63-4e09-b99c-92a6cc5f84ce")) + vsTextChanged + { + vsTextChangedMultiLine = 1, + vsTextChangedSave = 2, + vsTextChangedCaretMoved = 4, + vsTextChangedReplaceAll = 8, + vsTextChangedNewline = 16, + vsTextChangedFindStarting = 32 + }; + + struct __declspec(uuid("aa6f4085-33b6-4629-b9ea-692101007cc2")) + _OutputWindowEventsRoot : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_OutputWindowEvents( + /*[in]*/ BSTR PaneFilter, + /*[out,retval]*/ IDispatch * * ppDisp) = 0; + }; + + struct __declspec(uuid("6bc8c372-c6f0-4be6-b255-827ac190bf71")) + _TaskListEventsRoot : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_TaskListEvents( + /*[out,retval]*/ IDispatch * * ppDisp) = 0; + }; + + enum __declspec(uuid("f40a5d39-fd39-4f03-8358-4df3c338b448")) + vsStatusAnimation + { + vsStatusAnimationGeneral = 0, + vsStatusAnimationPrint = 1, + vsStatusAnimationSave = 2, + vsStatusAnimationDeploy = 3, + vsStatusAnimationSync = 4, + vsStatusAnimationBuild = 5, + vsStatusAnimationFind = 6 + }; + + struct __declspec(uuid("bdcaf240-2692-4713-902a-b110b1d0f100")) + IDTToolsOptionsPage : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall OnAfterCreated( + /*[in]*/ struct _DTE * DTEObject) = 0; + virtual HRESULT __stdcall GetProperties( + /*[in,out]*/ IDispatch * * PropertiesObject) = 0; + virtual HRESULT __stdcall OnOK() = 0; + virtual HRESULT __stdcall OnCancel() = 0; + virtual HRESULT __stdcall OnHelp() = 0; + }; + + enum __declspec(uuid("705cd8ac-d29b-11d2-aabd-00c04f688dde")) + vsStartUp + { + vsStartUpShowHomePage = 0, + vsStartUpLoadLastSolution = 1, + vsStartUpOpenProjectDialog = 2, + vsStartUpNewProjectDialog = 3, + vsStartUpEmptyEnvironment = 4 + }; + + enum __declspec(uuid("705cd8a4-d29b-11d2-aabd-00c04f688dde")) + vsFontCharSet + { + vsFontCharSetANSI = 0, + vsFontCharSetDefault = 1, + vsFontCharSetSymbol = 2, + vsFontCharSetShiftJIS = 128, + vsFontCharSetHangeul = 129, + vsFontCharSetGB2312 = 134, + vsFontCharSetChineseBig5 = 136, + vsFontCharSetOEM = 255, + vsFontCharSetJohab = 130, + vsFontCharSetHebrew = 177, + vsFontCharSetArabic = 178, + vsFontCharSetGreek = 161, + vsFontCharSetTurkish = 162, + vsFontCharSetVietnamese = 163, + vsFontCharSetThai = 222, + vsFontCharSetEastEurope = 238, + vsFontCharSetRussian = 204, + vsFontCharSetMac = 77, + vsFontCharSetBaltic = 186 + }; + + enum __declspec(uuid("947ffc03-8314-4288-bdd7-dfd282da40d5")) + vsBrowserViewSource + { + vsBrowserViewSourceSource = 1, + vsBrowserViewSourceDesign = 2, + vsBrowserViewSourceExternal = 3 + }; + + struct __declspec(uuid("a3286b03-5ac6-44f0-8cc3-ebed7f1124e5")) + _EnvironmentWebBrowser : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall put_UseDefaultHomePage( + VARIANT_BOOL pUseDefault) = 0; + virtual HRESULT __stdcall get_UseDefaultHomePage( + /*[out,retval]*/ VARIANT_BOOL * pUseDefault) = 0; + virtual HRESULT __stdcall put_HomePage( + BSTR URL) = 0; + virtual HRESULT __stdcall get_HomePage( + /*[out,retval]*/ BSTR * URL) = 0; + virtual HRESULT __stdcall put_UseDefaultSearchPage( + VARIANT_BOOL pUseDefault) = 0; + virtual HRESULT __stdcall get_UseDefaultSearchPage( + /*[out,retval]*/ VARIANT_BOOL * pUseDefault) = 0; + virtual HRESULT __stdcall put_SearchPage( + BSTR URL) = 0; + virtual HRESULT __stdcall get_SearchPage( + /*[out,retval]*/ BSTR * URL) = 0; + virtual HRESULT __stdcall put_ViewSourceIn( + enum vsBrowserViewSource Location) = 0; + virtual HRESULT __stdcall get_ViewSourceIn( + /*[out,retval]*/ enum vsBrowserViewSource * Location) = 0; + virtual HRESULT __stdcall put_ViewSourceExternalProgram( + BSTR Path) = 0; + virtual HRESULT __stdcall get_ViewSourceExternalProgram( + /*[out,retval]*/ BSTR * Path) = 0; + }; + + struct __declspec(uuid("aebded64-a206-11d3-b8b5-00c04f79f802")) + _EnvironmentHelp : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_PreferredLanguage( + /*[out,retval]*/ long * LCID) = 0; + virtual HRESULT __stdcall put_PreferredLanguage( + /*[in]*/ long LCID) = 0; + virtual HRESULT __stdcall get_PreferredCollection( + /*[out,retval]*/ BSTR * Namespace) = 0; + virtual HRESULT __stdcall put_PreferredCollection( + /*[in]*/ BSTR Namespace) = 0; + virtual HRESULT __stdcall get_External( + /*[out,retval]*/ VARIANT_BOOL * ExternalHelp) = 0; + virtual HRESULT __stdcall put_External( + /*[in]*/ VARIANT_BOOL ExternalHelp) = 0; + }; + + struct __declspec(uuid("e5d17051-d6e5-4da7-8b3a-ca888617a5e7")) + ColorableItems : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_Name( + /*[out,retval]*/ BSTR * pName) = 0; + virtual HRESULT __stdcall get_Foreground( + /*[out,retval]*/ OLE_COLOR * pColor) = 0; + virtual HRESULT __stdcall put_Foreground( + OLE_COLOR pColor) = 0; + virtual HRESULT __stdcall get_Background( + /*[out,retval]*/ OLE_COLOR * pColor) = 0; + virtual HRESULT __stdcall put_Background( + OLE_COLOR pColor) = 0; + virtual HRESULT __stdcall get_Bold( + /*[out,retval]*/ VARIANT_BOOL * Bold) = 0; + virtual HRESULT __stdcall put_Bold( + VARIANT_BOOL Bold) = 0; + }; + + struct __declspec(uuid("f25ae7e6-1460-4ba4-8e5e-bbbe746de353")) + FontsAndColorsItems : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall _NewEnum( + /*[out,retval]*/ IUnknown * * lppiuReturn) = 0; + virtual HRESULT __stdcall Item( + /*[in]*/ VARIANT index, + /*[out,retval]*/ struct ColorableItems * * pFontsAndColorsItem) = 0; + virtual HRESULT __stdcall get_Count( + /*[out,retval]*/ long * pCount) = 0; + }; + + struct __declspec(uuid("256068f6-1add-4f7b-ba76-571314c413ad")) + _FontsAndColors : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_FontFamily( + /*[out,retval]*/ BSTR * pFamily) = 0; + virtual HRESULT __stdcall put_FontFamily( + BSTR pFamily) = 0; + virtual HRESULT __stdcall get_FontCharacterSet( + /*[out,retval]*/ enum vsFontCharSet * pFontCharSet) = 0; + virtual HRESULT __stdcall put_FontCharacterSet( + enum vsFontCharSet pFontCharSet) = 0; + virtual HRESULT __stdcall get_FontSize( + /*[out,retval]*/ short * pSize) = 0; + virtual HRESULT __stdcall put_FontSize( + short pSize) = 0; + virtual HRESULT __stdcall get_FontsAndColorsItems( + /*[out,retval]*/ struct FontsAndColorsItems * * ppColorableItems) = 0; + }; + + struct __declspec(uuid("48e61d9c-8c8d-42d3-914b-46d70c8b7a40")) + _EnvironmentGeneral : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall put_OnStartUp( + /*[in]*/ enum vsStartUp pstartup) = 0; + virtual HRESULT __stdcall get_OnStartUp( + /*[out,retval]*/ enum vsStartUp * pstartup) = 0; + virtual HRESULT __stdcall put_ShowStatusBar( + /*[in]*/ VARIANT_BOOL pfshow) = 0; + virtual HRESULT __stdcall get_ShowStatusBar( + /*[out,retval]*/ VARIANT_BOOL * pfshow) = 0; + virtual HRESULT __stdcall put_WindowMenuContainsNItems( + /*[in]*/ long plCount) = 0; + virtual HRESULT __stdcall get_WindowMenuContainsNItems( + /*[out,retval]*/ long * plCount) = 0; + virtual HRESULT __stdcall put_MRUListContainsNItems( + /*[in]*/ long plCount) = 0; + virtual HRESULT __stdcall get_MRUListContainsNItems( + /*[out,retval]*/ long * plCount) = 0; + virtual HRESULT __stdcall get_AnimationSpeed( + /*[out,retval]*/ short * pSpeed) = 0; + virtual HRESULT __stdcall put_AnimationSpeed( + short pSpeed) = 0; + virtual HRESULT __stdcall get_Animations( + /*[out,retval]*/ VARIANT_BOOL * pAnimations) = 0; + virtual HRESULT __stdcall put_Animations( + VARIANT_BOOL pAnimations) = 0; + virtual HRESULT __stdcall get_ShowCommandWindowCompletion( + /*[out,retval]*/ VARIANT_BOOL * pComplete) = 0; + virtual HRESULT __stdcall put_ShowCommandWindowCompletion( + VARIANT_BOOL pComplete) = 0; + virtual HRESULT __stdcall put_CloseButtonActiveTabOnly( + VARIANT_BOOL CloseActiveOnly) = 0; + virtual HRESULT __stdcall get_CloseButtonActiveTabOnly( + /*[out,retval]*/ VARIANT_BOOL * CloseActiveOnly) = 0; + virtual HRESULT __stdcall put_AutohidePinActiveTabOnly( + VARIANT_BOOL AutohidePinActiveOnly) = 0; + virtual HRESULT __stdcall get_AutohidePinActiveTabOnly( + /*[out,retval]*/ VARIANT_BOOL * AutohidePinActiveOnly) = 0; + }; + + struct __declspec(uuid("f809cab6-2c9f-41f2-a5af-e26fb80e62ad")) + _EnvironmentFontsAndColors : IDispatch + {}; + + struct __declspec(uuid("478f06d4-5d57-473f-9b74-5f8e88efa5e7")) + _EnvironmentProjectsAndSolution : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall put_OnRunOrPreview( + /*[in]*/ enum vsSaveChanges pbld) = 0; + virtual HRESULT __stdcall get_OnRunOrPreview( + /*[out,retval]*/ enum vsSaveChanges * pbld) = 0; + virtual HRESULT __stdcall put_ProjectsLocation( + /*[in]*/ BSTR pLocation) = 0; + virtual HRESULT __stdcall get_ProjectsLocation( + /*[out,retval]*/ BSTR * pLocation) = 0; + virtual HRESULT __stdcall put_ShowOutputWindowBeforeBuild( + /*[in]*/ VARIANT_BOOL pfshow) = 0; + virtual HRESULT __stdcall get_ShowOutputWindowBeforeBuild( + /*[out,retval]*/ VARIANT_BOOL * pfshow) = 0; + virtual HRESULT __stdcall put_ShowTaskListAfterBuild( + /*[in]*/ VARIANT_BOOL pfshow) = 0; + virtual HRESULT __stdcall get_ShowTaskListAfterBuild( + /*[out,retval]*/ VARIANT_BOOL * pfshow) = 0; + }; + + struct __declspec(uuid("76ed1c48-ed86-4e9e-acf8-a40e765daf25")) + _EnvironmentDocuments : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall put_ReuseSavedActiveDocWindow( + VARIANT_BOOL pReuse) = 0; + virtual HRESULT __stdcall get_ReuseSavedActiveDocWindow( + /*[out,retval]*/ VARIANT_BOOL * pReuse) = 0; + virtual HRESULT __stdcall put_DetectFileChangesOutsideIDE( + /*[in]*/ VARIANT_BOOL pfAutoRead) = 0; + virtual HRESULT __stdcall get_DetectFileChangesOutsideIDE( + /*[out,retval]*/ VARIANT_BOOL * pfAutoRead) = 0; + virtual HRESULT __stdcall put_AutoloadExternalChanges( + /*[in]*/ VARIANT_BOOL pfAutoload) = 0; + virtual HRESULT __stdcall get_AutoloadExternalChanges( + /*[out,retval]*/ VARIANT_BOOL * pfAutoload) = 0; + virtual HRESULT __stdcall put_InitializeOpenFileFromCurrentDocument( + /*[in]*/ VARIANT_BOOL pfInit) = 0; + virtual HRESULT __stdcall get_InitializeOpenFileFromCurrentDocument( + /*[out,retval]*/ VARIANT_BOOL * pfInit) = 0; + virtual HRESULT __stdcall put_MiscFilesProjectSavesLastNItems( + /*[in]*/ long plCount) = 0; + virtual HRESULT __stdcall get_MiscFilesProjectSavesLastNItems( + /*[out,retval]*/ long * plCount) = 0; + virtual HRESULT __stdcall get_FindReplaceShowMessageBoxes( + /*[out,retval]*/ VARIANT_BOOL * pShow) = 0; + virtual HRESULT __stdcall put_FindReplaceShowMessageBoxes( + VARIANT_BOOL pShow) = 0; + virtual HRESULT __stdcall get_FindReplaceInitializeFromEditor( + /*[out,retval]*/ VARIANT_BOOL * pShow) = 0; + virtual HRESULT __stdcall put_FindReplaceInitializeFromEditor( + VARIANT_BOOL pShow) = 0; + }; + + struct __declspec(uuid("4bc18a5b-dbb6-4af5-a443-2e3f19365304")) + _EnvironmentTaskList : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_ConfirmTaskDeletion( + /*[out,retval]*/ VARIANT_BOOL * pConfirm) = 0; + virtual HRESULT __stdcall put_ConfirmTaskDeletion( + VARIANT_BOOL pConfirm) = 0; + virtual HRESULT __stdcall get_WarnOnAddingHiddenItem( + /*[out,retval]*/ VARIANT_BOOL * pWarn) = 0; + virtual HRESULT __stdcall put_WarnOnAddingHiddenItem( + VARIANT_BOOL pWarn) = 0; + virtual HRESULT __stdcall get_CommentTokens( + /*[out,retval]*/ VARIANT * pTokens) = 0; + virtual HRESULT __stdcall put_CommentTokens( + VARIANT pTokens) = 0; + }; + + struct __declspec(uuid("9c722678-490d-408f-98ae-b6b9a68aa45d")) + _EnvironmentKeyboard : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall put_Scheme( + /*[in]*/ BSTR pbstr) = 0; + virtual HRESULT __stdcall get_Scheme( + /*[out,retval]*/ BSTR * pbstr) = 0; + }; + + struct __declspec(uuid("86c31347-5b52-4715-b454-a6e5fcab975d")) + IExtensibleObject : IUnknown + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall GetAutomationObject( + /*[in]*/ BSTR Name, + /*[in]*/ struct IExtensibleObjectSite * pParent, + /*[out]*/ IDispatch * * ppDisp) = 0; + }; + const LPSTR vsTaskCategoryBuildCompile = (char*) "BuildCompile"; + const LPSTR vsTaskCategoryComment = (char*) "Comment"; + const LPSTR vsTaskCategoryShortcut = (char*) "Shortcut"; + const LPSTR vsTaskCategoryUser = (char*) "User"; + const LPSTR vsTaskCategoryMisc = (char*) "Misc"; + const LPSTR vsTaskCategoryHTML = (char*) "HTML"; + const LPSTR vsDocumentKindText = (char*) "{8E7B96A8-E33D-11D0-A6D5-00C04FB67F6A}"; + const LPSTR vsDocumentKindHTML = (char*) "{C76D83F8-A489-11D0-8195-00A0C91BBEE3}"; + const LPSTR vsDocumentKindResource = (char*) "{00000000-0000-0000-0000-000000000000}"; + const LPSTR vsDocumentKindBinary = (char*) "{25834150-CD7E-11D0-92DF-00A0C9138C45}"; + const LPSTR vsViewKindPrimary = (char*) "{00000000-0000-0000-0000-000000000000}"; + const LPSTR vsViewKindAny = (char*) "{FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF}"; + const LPSTR vsViewKindDebugging = (char*) "{7651A700-06E5-11D1-8EBD-00A0C90F26EA}"; + const LPSTR vsViewKindCode = (char*) "{7651A701-06E5-11D1-8EBD-00A0C90F26EA}"; + const LPSTR vsViewKindDesigner = (char*) "{7651A702-06E5-11D1-8EBD-00A0C90F26EA}"; + const LPSTR vsViewKindTextView = (char*) "{7651A703-06E5-11D1-8EBD-00A0C90F26EA}"; + const LPSTR vsWindowKindTaskList = (char*) "{4A9B7E51-AA16-11D0-A8C5-00A0C921A4D2}"; + const LPSTR vsWindowKindToolbox = (char*) "{B1E99781-AB81-11D0-B683-00AA00A3EE26}"; + const LPSTR vsWindowKindCallStack = (char*) "{0504FF91-9D61-11D0-A794-00A0C9110051}"; + const LPSTR vsWindowKindThread = (char*) "{E62CE6A0-B439-11D0-A79D-00A0C9110051}"; + const LPSTR vsWindowKindLocals = (char*) "{4A18F9D0-B838-11D0-93EB-00A0C90F2734}"; + const LPSTR vsWindowKindAutoLocals = (char*) "{F2E84780-2AF1-11D1-A7FA-00A0C9110051}"; + const LPSTR vsWindowKindWatch = (char*) "{90243340-BD7A-11D0-93EF-00A0C90F2734}"; + const LPSTR vsWindowKindProperties = (char*) "{EEFA5220-E298-11D0-8F78-00A0C9110057}"; + const LPSTR vsWindowKindSolutionExplorer = (char*) "{3AE79031-E1BC-11D0-8F78-00A0C9110057}"; + const LPSTR vsWindowKindOutput = (char*) "{34E76E81-EE4A-11D0-AE2E-00A0C90FFFC3}"; + const LPSTR vsWindowKindObjectBrowser = (char*) "{269A02DC-6AF8-11D3-BDC4-00C04F688E50}"; + const LPSTR vsWindowKindMacroExplorer = (char*) "{07CD18B4-3BA1-11D2-890A-0060083196C6}"; + const LPSTR vsWindowKindDynamicHelp = (char*) "{66DBA47C-61DF-11D2-AA79-00C04F990343}"; + const LPSTR vsWindowKindClassView = (char*) "{C9C0AE26-AA77-11D2-B3F0-0000F87570EE}"; + const LPSTR vsWindowKindResourceView = (char*) "{2D7728C2-DE0A-45b5-99AA-89B609DFDE73}"; + const LPSTR vsWindowKindDocumentOutline = (char*) "{25F7E850-FFA1-11D0-B63F-00A0C922E851}"; + const LPSTR vsWindowKindServerExplorer = (char*) "{74946827-37A0-11D2-A273-00C04F8EF4FF}"; + const LPSTR vsWindowKindCommandWindow = (char*) "{28836128-FC2C-11D2-A433-00C04F72D18A}"; + const LPSTR vsWindowKindFindSymbol = (char*) "{53024D34-0EF5-11D3-87E0-00C04F7971A5}"; + const LPSTR vsWindowKindFindSymbolResults = (char*) "{68487888-204A-11D3-87EB-00C04F7971A5}"; + const LPSTR vsWindowKindFindReplace = (char*) "{CF2DDC32-8CAD-11D2-9302-005345000000}"; + const LPSTR vsWindowKindFindResults1 = (char*) "{0F887920-C2B6-11D2-9375-0080C747D9A0}"; + const LPSTR vsWindowKindFindResults2 = (char*) "{0F887921-C2B6-11D2-9375-0080C747D9A0}"; + const LPSTR vsWindowKindMainWindow = (char*) "{9DDABE98-1D02-11D3-89A1-00C04F688DDE}"; + const LPSTR vsWindowKindLinkedWindowFrame = (char*) "{9DDABE99-1D02-11D3-89A1-00C04F688DDE}"; + const LPSTR vsWindowKindWebBrowser = (char*) "{E8B06F52-6D01-11D2-AA7D-00C04F990343}"; + const LPSTR vsWizardAddSubProject = (char*) "{0F90E1D2-4999-11D1-B6D1-00A0C90F2744}"; + const LPSTR vsWizardAddItem = (char*) "{0F90E1D1-4999-11D1-B6D1-00A0C90F2744}"; + const LPSTR vsWizardNewProject = (char*) "{0F90E1D0-4999-11D1-B6D1-00A0C90F2744}"; + const LPSTR vsProjectKindMisc = (char*) "{66A2671D-8FB5-11D2-AA7E-00C04F688DDE}"; + const LPSTR vsProjectItemsKindMisc = (char*) "{66A2671E-8FB5-11D2-AA7E-00C04F688DDE}"; + const LPSTR vsProjectItemKindMisc = (char*) "{66A2671F-8FB5-11D2-AA7E-00C04F688DDE}"; + const LPSTR vsProjectKindUnmodeled = (char*) "{67294A52-A4F0-11D2-AA88-00C04F688DDE}"; + const LPSTR vsProjectKindSolutionItems = (char*) "{66A26720-8FB5-11D2-AA7E-00C04F688DDE}"; + const LPSTR vsProjectItemsKindSolutionItems = (char*) "{66A26721-8FB5-11D2-AA7E-00C04F688DDE}"; + const LPSTR vsProjectItemKindSolutionItems = (char*) "{66A26722-8FB5-11D2-AA7E-00C04F688DDE}"; + const LPSTR vsProjectsKindSolution = (char*) "{96410B9F-3542-4A14-877F-BC7227B51D3B}"; + const LPSTR vsAddInCmdGroup = (char*) "{1E58696E-C90F-11D2-AAB2-00C04F688DDE}"; + const LPSTR vsContextSolutionBuilding = (char*) "{ADFC4E60-0397-11D1-9F4E-00A0C911004F}"; + const LPSTR vsContextDebugging = (char*) "{ADFC4E61-0397-11D1-9F4E-00A0C911004F}"; + const LPSTR vsContextFullScreenMode = (char*) "{ADFC4E62-0397-11D1-9F4E-00A0C911004F}"; + const LPSTR vsContextDesignMode = (char*) "{ADFC4E63-0397-11D1-9F4E-00A0C911004F}"; + const LPSTR vsContextNoSolution = (char*) "{ADFC4E64-0397-11D1-9F4E-00A0C911004F}"; + const LPSTR vsContextEmptySolution = (char*) "{ADFC4E65-0397-11D1-9F4E-00A0C911004F}"; + const LPSTR vsContextSolutionHasSingleProject = (char*) "{ADFC4E66-0397-11D1-9F4E-00A0C911004F}"; + const LPSTR vsContextSolutionHasMultipleProjects = (char*) "{93694FA0-0397-11D1-9F4E-00A0C911004F}"; + const LPSTR vsContextMacroRecording = (char*) "{04BBF6A5-4697-11D2-890E-0060083196C6}"; + const LPSTR vsContextMacroRecordingToolbar = (char*) "{85A70471-270A-11D2-88F9-0060083196C6}"; + const LPSTR vsMiscFilesProjectUniqueName = (char*) ""; + const LPSTR vsSolutionItemsProjectUniqueName = (char*) ""; + const LPSTR vsProjectItemKindPhysicalFile = (char*) "{6BB5F8EE-4483-11D3-8BCF-00C04F8EC28C}"; + const LPSTR vsProjectItemKindPhysicalFolder = (char*) "{6BB5F8EF-4483-11D3-8BCF-00C04F8EC28C}"; + const LPSTR vsProjectItemKindVirtualFolder = (char*) "{6BB5F8F0-4483-11D3-8BCF-00C04F8EC28C}"; + const LPSTR vsProjectItemKindSubProject = (char*) "{EA6618E8-6E24-4528-94BE-6889FE16485C}"; + const LPSTR vsext_vk_Primary = (char*) "{00000000-0000-0000-0000-000000000000}"; + const LPSTR vsext_vk_Debugging = (char*) "{7651A700-06E5-11D1-8EBD-00A0C90F26EA}"; + const LPSTR vsext_vk_Code = (char*) "{7651A701-06E5-11D1-8EBD-00A0C90F26EA}"; + const LPSTR vsext_vk_Designer = (char*) "{7651A702-06E5-11D1-8EBD-00A0C90F26EA}"; + const LPSTR vsext_vk_TextView = (char*) "{7651A703-06E5-11D1-8EBD-00A0C90F26EA}"; + const LPSTR vsext_wk_TaskList = (char*) "{4A9B7E51-AA16-11D0-A8C5-00A0C921A4D2}"; + const LPSTR vsext_wk_Toolbox = (char*) "{B1E99781-AB81-11D0-B683-00AA00A3EE26}"; + const LPSTR vsext_wk_CallStackWindow = (char*) "{0504FF91-9D61-11D0-A794-00A0C9110051}"; + const LPSTR vsext_wk_ThreadWindow = (char*) "{E62CE6A0-B439-11D0-A79D-00A0C9110051}"; + const LPSTR vsext_wk_LocalsWindow = (char*) "{4A18F9D0-B838-11D0-93EB-00A0C90F2734}"; + const LPSTR vsext_wk_AutoLocalsWindow = (char*) "{F2E84780-2AF1-11D1-A7FA-00A0C9110051}"; + const LPSTR vsext_wk_WatchWindow = (char*) "{90243340-BD7A-11D0-93EF-00A0C90F2734}"; + const LPSTR vsext_wk_ImmedWindow = (char*) "{98731960-965C-11D0-A78F-00A0C9110051}"; + const LPSTR vsext_wk_PropertyBrowser = (char*) "{EEFA5220-E298-11D0-8F78-00A0C9110057}"; + const LPSTR vsext_wk_SProjectWindow = (char*) "{3AE79031-E1BC-11D0-8F78-00A0C9110057}"; + const LPSTR vsext_wk_OutputWindow = (char*) "{34E76E81-EE4A-11D0-AE2E-00A0C90FFFC3}"; + const LPSTR vsext_wk_ObjectBrowser = (char*) "{269A02DC-6AF8-11D3-BDC4-00C04F688E50}"; + const LPSTR vsext_wk_ContextWindow = (char*) "{66DBA47C-61DF-11D2-AA79-00C04F990343}"; + const LPSTR vsext_wk_ClassView = (char*) "{C9C0AE26-AA77-11D2-B3F0-0000F87570EE}"; + const LPSTR vsext_GUID_AddItemWizard = (char*) "{0F90E1D1-4999-11D1-B6D1-00A0C90F2744}"; + const LPSTR vsext_GUID_NewProjectWizard = (char*) "{0F90E1D0-4999-11D1-B6D1-00A0C90F2744}"; + const LPSTR dsCPP = (char*) "C/C++"; + const LPSTR dsHTML_IE3 = (char*) "HTML - IE 3.0"; + const LPSTR dsHTML_RFC1866 = (char*) "HTML 2.0 (RFC 1866)"; + const LPSTR dsFortran_Fixed = (char*) "Fortran Fixed"; + const LPSTR dsFortran_Free = (char*) "Fortran Free"; + const LPSTR dsJava = (char*) "Java"; + const LPSTR dsVBSMacro = (char*) "VBS Macro"; + const LPSTR dsIDL = (char*) "ODL/IDL"; + const LPSTR vsCATIDSolution = (char*) "{52AEFF70-BBD8-11d2-8598-006097C68E81}"; + const LPSTR vsCATIDSolutionBrowseObject = (char*) "{A2392464-7C22-11d3-BDCA-00C04F688E50}"; + const LPSTR vsCATIDMiscFilesProject = (char*) "{610d4612-d0d5-11d2-8599-006097c68e81}"; + const LPSTR vsCATIDMiscFilesProjectItem = (char*) "{610d4613-d0d5-11d2-8599-006097c68e81}"; + const LPSTR vsCATIDGenericProject = (char*) "{610d4616-d0d5-11d2-8599-006097c68e81}"; + const LPSTR vsCATIDDocument = (char*) "{610d4611-d0d5-11d2-8599-006097c68e81}"; + + enum __declspec(uuid("a457303f-d058-4415-a2b4-a81b148c7689")) + vsFindOptions + { + vsFindOptionsNone = 0, + vsFindOptionsMatchWholeWord = 2, + vsFindOptionsMatchCase = 4, + vsFindOptionsRegularExpression = 8, + vsFindOptionsBackwards = 128, + vsFindOptionsFromStart = 256, + vsFindOptionsMatchInHiddenText = 512, + vsFindOptionsWildcards = 1024, + vsFindOptionsSearchSubfolders = 4096, + vsFindOptionsKeepModifiedDocumentsOpen = 8192 + }; + + enum __declspec(uuid("29182bd4-48a8-4e4b-81dd-1b742a3a5203")) + vsMovementOptions + { + vsMovementOptionsMove = 0, + vsMovementOptionsExtend = 1 + }; + + enum __declspec(uuid("11b63a24-6200-48cd-9b8d-fc6a6fb9eff0")) + vsGoToLineOptions + { + vsGoToLineOptionsLast = -1, + vsGoToLineOptionsFirst = -2 + }; + + enum __declspec(uuid("c512dde3-a220-4373-8950-e6636f8cc546")) + vsSmartFormatOptions + { + vsSmartFormatOptionsNone = 0, + vsSmartFormatOptionsBlock = 1, + vsSmartFormatOptionsSmart = 2 + }; + + enum __declspec(uuid("79515b53-8294-4f96-aa96-dd16bf126703")) + vsInsertFlags + { + vsInsertFlagsCollapseToEnd = 1, + vsInsertFlagsCollapseToStart = 2, + vsInsertFlagsContainNewText = 4, + vsInsertFlagsInsertAtEnd = 8, + vsInsertFlagsInsertAtStart = 16 + }; + + enum __declspec(uuid("4eb2c04f-8a83-4363-81db-dbb76cd76812")) + vsMoveToColumnLine + { + vsMoveToColumnLineFirst = 0, + vsMoveToColumnLineLast = 1 + }; + + enum __declspec(uuid("3740dcf8-b8b2-49a9-a1ab-944c84876c3c")) + vsEPReplaceTextOptions + { + vsEPReplaceTextKeepMarkers = 1, + vsEPReplaceTextNormalizeNewlines = 2, + vsEPReplaceTextTabsSpaces = 4, + vsEPReplaceTextAutoformat = 8 + }; + + struct __declspec(uuid("2e1bfd1c-5b26-4aca-b97b-ed9d261ba3e7")) + IVsTextEditGeneral : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall put_SelectionMargin( + /*[in]*/ VARIANT_BOOL pfSelectionMargin) = 0; + virtual HRESULT __stdcall get_SelectionMargin( + /*[out,retval]*/ VARIANT_BOOL * pfSelectionMargin) = 0; + virtual HRESULT __stdcall put_GoToAnchorAfterEscape( + /*[in]*/ VARIANT_BOOL pfGoToAnchorAfterEscape) = 0; + virtual HRESULT __stdcall get_GoToAnchorAfterEscape( + /*[out,retval]*/ VARIANT_BOOL * pfGoToAnchorAfterEscape) = 0; + virtual HRESULT __stdcall put_DragNDropTextEditing( + /*[in]*/ VARIANT_BOOL pfDragNDropTextEditing) = 0; + virtual HRESULT __stdcall get_DragNDropTextEditing( + /*[out,retval]*/ VARIANT_BOOL * pfDragNDropTextEditing) = 0; + virtual HRESULT __stdcall put_UndoCaretActions( + /*[in]*/ VARIANT_BOOL pfUndoCaretActions) = 0; + virtual HRESULT __stdcall get_UndoCaretActions( + /*[out,retval]*/ VARIANT_BOOL * pfUndoCaretActions) = 0; + virtual HRESULT __stdcall put_MarginIndicatorBar( + /*[in]*/ VARIANT_BOOL pfMarginIndicatorBar) = 0; + virtual HRESULT __stdcall get_MarginIndicatorBar( + /*[out,retval]*/ VARIANT_BOOL * pfMarginIndicatorBar) = 0; + virtual HRESULT __stdcall put_HorizontalScrollBar( + /*[in]*/ VARIANT_BOOL pfHorizontalScrollBar) = 0; + virtual HRESULT __stdcall get_HorizontalScrollBar( + /*[out,retval]*/ VARIANT_BOOL * pfHorizontalScrollBar) = 0; + virtual HRESULT __stdcall put_VerticalScrollBar( + /*[in]*/ VARIANT_BOOL pfVerticalScrollBar) = 0; + virtual HRESULT __stdcall get_VerticalScrollBar( + /*[out,retval]*/ VARIANT_BOOL * pfVerticalScrollBar) = 0; + virtual HRESULT __stdcall put_AutoDelimiterHighlighting( + /*[in]*/ VARIANT_BOOL pfHighlighting) = 0; + virtual HRESULT __stdcall get_AutoDelimiterHighlighting( + /*[out,retval]*/ VARIANT_BOOL * pfHighlighting) = 0; + }; + + struct __declspec(uuid("5943bd7e-d722-42db-a251-fe2add8711ea")) + IVsTextEditPerLanguage : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall put_TabSize( + /*[in]*/ short piTabSize) = 0; + virtual HRESULT __stdcall get_TabSize( + /*[out,retval]*/ short * piTabSize) = 0; + virtual HRESULT __stdcall put_IndentSize( + /*[in]*/ short piIndentSize) = 0; + virtual HRESULT __stdcall get_IndentSize( + /*[out,retval]*/ short * piIndentSize) = 0; + virtual HRESULT __stdcall put_InsertTabs( + /*[in]*/ VARIANT_BOOL pfInsertTabs) = 0; + virtual HRESULT __stdcall get_InsertTabs( + /*[out,retval]*/ VARIANT_BOOL * pfInsertTabs) = 0; + virtual HRESULT __stdcall put_IndentStyle( + /*[in]*/ vsIndentStyle pfIndentStyle) = 0; + virtual HRESULT __stdcall get_IndentStyle( + /*[out,retval]*/ vsIndentStyle * pfIndentStyle) = 0; + virtual HRESULT __stdcall put_AutoListMembers( + /*[in]*/ VARIANT_BOOL pfAutoListMembers) = 0; + virtual HRESULT __stdcall get_AutoListMembers( + /*[out,retval]*/ VARIANT_BOOL * pfAutoListMembers) = 0; + virtual HRESULT __stdcall put_AutoListParams( + /*[in]*/ VARIANT_BOOL pfAutoListParams) = 0; + virtual HRESULT __stdcall get_AutoListParams( + /*[out,retval]*/ VARIANT_BOOL * pfAutoListParams) = 0; + virtual HRESULT __stdcall put_VirtualSpace( + /*[in]*/ VARIANT_BOOL pfVirtualSpace) = 0; + virtual HRESULT __stdcall get_VirtualSpace( + /*[out,retval]*/ VARIANT_BOOL * pfVirtualSpace) = 0; + virtual HRESULT __stdcall put_EnableLeftClickForURLs( + /*[in]*/ VARIANT_BOOL pfHotURLs) = 0; + virtual HRESULT __stdcall get_EnableLeftClickForURLs( + /*[out,retval]*/ VARIANT_BOOL * pfHotURLs) = 0; + virtual HRESULT __stdcall put_WordWrap( + /*[in]*/ VARIANT_BOOL pfWrap) = 0; + virtual HRESULT __stdcall get_WordWrap( + /*[out,retval]*/ VARIANT_BOOL * pfWrap) = 0; + virtual HRESULT __stdcall put_ShowLineNumbers( + /*[in]*/ VARIANT_BOOL pfshow) = 0; + virtual HRESULT __stdcall get_ShowLineNumbers( + /*[out,retval]*/ VARIANT_BOOL * pfshow) = 0; + virtual HRESULT __stdcall put_ShowNavigationBar( + /*[in]*/ VARIANT_BOOL pfshow) = 0; + virtual HRESULT __stdcall get_ShowNavigationBar( + /*[out,retval]*/ VARIANT_BOOL * pfshow) = 0; + virtual HRESULT __stdcall put_HideAdvancedMembers( + /*[in]*/ VARIANT_BOOL pfHide) = 0; + virtual HRESULT __stdcall get_HideAdvancedMembers( + /*[out,retval]*/ VARIANT_BOOL * pfHide) = 0; + }; + + enum _vsIndentStyle + { + vsIndentStyleNone = 0, + vsIndentStyleDefault = 1, + vsIndentStyleSmart = 2 + }; + + struct __declspec(uuid("f39ab913-e6c9-4546-a265-1e43f8de924c")) + IVsTextEditFonts : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall put_FontFamily( + /*[in]*/ BSTR pbstrFontFamily) = 0; + virtual HRESULT __stdcall get_FontFamily( + /*[out,retval]*/ BSTR * pbstrFontFamily) = 0; + virtual HRESULT __stdcall put_FontCharacterSet( + /*[in]*/ enum vsFontCharSet pbstrCharacterSet) = 0; + virtual HRESULT __stdcall get_FontCharacterSet( + /*[out,retval]*/ enum vsFontCharSet * pbstrCharacterSet) = 0; + virtual HRESULT __stdcall put_FontSize( + /*[in]*/ short piFontSize) = 0; + virtual HRESULT __stdcall get_FontSize( + /*[out,retval]*/ short * piFontSize) = 0; + }; + + enum __declspec(uuid("c106c8dc-6d0c-11d1-b2c9-00c04fb6c6ff")) + vsext_FontCharSet + { + vsext_fontcs_ANSI = 0, + vsext_fontcs_DEFAULT = 1, + vsext_fontcs_SYMBOL = 2, + vsext_fontcs_SHIFTJIS = 128, + vsext_fontcs_HANGEUL = 129, + vsext_fontcs_GB2312 = 134, + vsext_fontcs_CHINESEBIG5 = 136, + vsext_fontcs_OEM = 255, + vsext_fontcs_JOHAB = 130, + vsext_fontcs_HEBREW = 177, + vsext_fontcs_ARABIC = 178, + vsext_fontcs_GREEK = 161, + vsext_fontcs_TURKISH = 162, + vsext_fontcs_VIETNAMESE = 163, + vsext_fontcs_THAI = 222, + vsext_fontcs_EASTEUROPE = 238, + vsext_fontcs_RUSSIAN = 204, + vsext_fontcs_MAC = 77, + vsext_fontcs_BALTIC = 186 + }; + + enum VSEXECRESULT + { + RESULT_Success = -1, + RESULT_Failure = 0, + RESULT_Cancel = 1 + }; + + enum __declspec(uuid("91aab9c3-da83-473a-8bc9-1a2730865995")) + vsext_DisplayMode + { + vsext_dm_SDI = 0, + vsext_dm_MDI = 1 + }; + + enum __declspec(uuid("e4b9e990-fd59-11d0-bbc6-00a0c90f2744")) + vsext_WindowType + { + vsext_wt_CodeWindow = 0, + vsext_wt_Designer = 1, + vsext_wt_Browser = 2, + vsext_wt_Watch = 3, + vsext_wt_Locals = 4, + vsext_wt_Immediate = 5, + vsext_wt_ProjectWindow = 6, + vsext_wt_PropertyWindow = 7, + vsext_wt_Find = 8, + vsext_wt_FindReplace = 9, + vsext_wt_Toolbox = 10, + vsext_wt_LinkedWindowFrame = 11, + vsext_wt_MainWindow = 12, + vsext_wt_Preview = 13, + vsext_wt_ColorPalette = 14, + vsext_wt_ToolWindow = 15, + vsext_wt_Document = 16, + vsext_wt_OutPutWindow = 17, + vsext_wt_TaskList = 18, + vsext_wt_Autos = 19, + vsext_wt_CallStack = 20, + vsext_wt_Threads = 21, + vsext_wt_DocumentOutline = 22, + vsext_wt_RunningDocuments = 23 + }; + + enum __declspec(uuid("e0c72e51-6b99-489b-aca6-90cedce888e7")) + vsext_WindowState + { + vsext_ws_Normal = 0, + vsext_ws_Minimize = 1, + vsext_ws_Maximize = 2 + }; + + enum __declspec(uuid("97653acf-d869-4ec0-b450-e9842457c729")) + vsext_LinkedWindowType + { + vsext_lwt_Docked = 0, + vsext_lwt_Tabbed = 1 + }; + + enum __declspec(uuid("a5578594-18e0-11d1-bbdb-00a0c90f2744")) + vsext_StartUp + { + vsext_su_EMPTY_ENVIRONMENT = 0, + vsext_su_NEW_SOLUTION_DIALOG = 1, + vsext_su_LOAD_LAST_SOLUTION = 2 + }; + + enum __declspec(uuid("47046891-19f7-11d1-bcaf-000000000000")) + vsext_Build + { + vsext_bld_SAVE_CHANGES = 0, + vsext_bld_CONFIRM_SAVE = 1, + vsext_bld_NO_SAVE = 2 + }; + + enum __declspec(uuid("bdbe10aa-74d3-498a-a464-8074cd5e99cb")) + DsTextSearchOptions + { + dsMatchWord = 2, + dsMatchCase = 4, + dsMatchNoRegExp = 0, + dsMatchRegExp = 8, + dsMatchRegExpB = 16, + dsMatchRegExpE = 32, + dsMatchRegExpCur = 64, + dsMatchForward = 0, + dsMatchBackward = 128, + dsMatchFromStart = 256 + }; + + enum __declspec(uuid("99744ec4-7a72-11d2-adc9-00c04f7971c3")) + DsSaveChanges + { + dsSaveChangesYes = 1, + dsSaveChangesNo = 2, + dsSaveChangesPrompt = 3 + }; + + enum __declspec(uuid("6269c78d-5591-40d6-a095-5bac8ba07478")) + DsGoToLineOptions + { + dsLastLine = -1 + }; + + enum __declspec(uuid("95751137-ac07-4c76-a219-4be5d381985d")) + DsStartOfLineOptions + { + dsFirstColumn = 0, + dsFirstText = 1 + }; + + enum __declspec(uuid("4b58f807-6f08-4b41-abaf-b5bca4869d2c")) + DsMovementOptions + { + dsMove = 0, + dsExtend = 1 + }; + + enum __declspec(uuid("31445615-bcae-4ba0-a99c-246bc660cfe8")) + DsWhitespaceOptions + { + dsHorizontal = 0, + dsVertical = 1 + }; + + enum __declspec(uuid("f7d38518-e803-4462-8fa2-e481642d42fb")) + DsCaseOptions + { + dsLowercase = 1, + dsUppercase = 2, + dsCapitalize = 3 + }; + + enum __declspec(uuid("8d78b9a9-a3be-49d0-aa97-bf7fa46d8ea2")) + dsSaveStatus + { + dsSaveCancelled = 2, + dsSaveSucceeded = 1 + }; + + enum __declspec(uuid("44160df5-e305-4d85-b7fe-6b5a1b81b9b0")) + vsHTMLTabs + { + vsHTMLTabsSource = 0, + vsHTMLTabsDesign = 1 + }; + + struct __declspec(uuid("04a72314-32e9-48e2-9b87-a63603454f3e")) + _DTE : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_Name( + /*[out,retval]*/ BSTR * lpbstrReturn) = 0; + virtual HRESULT __stdcall get_FileName( + /*[out,retval]*/ BSTR * lpbstrReturn) = 0; + virtual HRESULT __stdcall get_Version( + /*[out,retval]*/ BSTR * lpbstrReturn) = 0; + virtual HRESULT __stdcall get_CommandBars( + /*[out,retval]*/ IDispatch * * ppcbs) = 0; + virtual HRESULT __stdcall get_Windows( + /*[out,retval]*/ struct Windows * * ppwnsVBWindows) = 0; + virtual HRESULT __stdcall get_Events( + /*[out,retval]*/ struct Events * * ppevtEvents) = 0; + virtual HRESULT __stdcall get_AddIns( + /*[out,retval]*/ struct AddIns * * lpppAddIns) = 0; + virtual HRESULT __stdcall get_MainWindow( + /*[out,retval]*/ struct Window * * ppWin) = 0; + virtual HRESULT __stdcall get_ActiveWindow( + /*[out,retval]*/ struct Window * * ppwinActive) = 0; + virtual HRESULT __stdcall Quit() = 0; + virtual HRESULT __stdcall get_DisplayMode( + /*[out,retval]*/ enum vsDisplay * lpDispMode) = 0; + virtual HRESULT __stdcall put_DisplayMode( + /*[in]*/ enum vsDisplay lpDispMode) = 0; + virtual HRESULT __stdcall get_Solution( + /*[out,retval]*/ struct _Solution * * ppSolution) = 0; + virtual HRESULT __stdcall get_Commands( + /*[out,retval]*/ struct Commands * * ppCommands) = 0; + virtual HRESULT __stdcall GetObject( + /*[in]*/ BSTR Name, + /*[out,retval]*/ IDispatch * * ppObject) = 0; + virtual HRESULT __stdcall get_Properties( + BSTR Category, + BSTR Page, + /*[out,retval]*/ struct Properties * * ppObject) = 0; + virtual HRESULT __stdcall get_SelectedItems( + /*[out,retval]*/ struct SelectedItems * * ppSelectedItems) = 0; + virtual HRESULT __stdcall get_CommandLineArguments( + /*[out,retval]*/ BSTR * lpbstrReturn) = 0; + virtual HRESULT __stdcall OpenFile( + /*[in]*/ BSTR ViewKind, + /*[in]*/ BSTR FileName, + /*[out,retval]*/ struct Window * * ppWin) = 0; + virtual HRESULT __stdcall get_IsOpenFile( + /*[in]*/ BSTR ViewKind, + /*[in]*/ BSTR FileName, + /*[out,retval]*/ VARIANT_BOOL * lpfReturn) = 0; + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * lppaReturn) = 0; + virtual HRESULT __stdcall get_LocaleID( + /*[out,retval]*/ long * lpReturn) = 0; + virtual HRESULT __stdcall get_WindowConfigurations( + /*[out,retval]*/ struct WindowConfigurations * * WindowConfigurationsObject) = 0; + virtual HRESULT __stdcall get_Documents( + /*[out,retval]*/ struct Documents * * ppDocuments) = 0; + virtual HRESULT __stdcall get_ActiveDocument( + /*[out,retval]*/ struct Document * * ppDocument) = 0; + virtual HRESULT __stdcall ExecuteCommand( + /*[in]*/ BSTR CommandName, + /*[in]*/ BSTR CommandArgs) = 0; + virtual HRESULT __stdcall get_Globals( + /*[out,retval]*/ struct Globals * * ppGlobals) = 0; + virtual HRESULT __stdcall get_StatusBar( + /*[out,retval]*/ struct StatusBar * * ppStatusBar) = 0; + virtual HRESULT __stdcall get_FullName( + /*[out,retval]*/ BSTR * lpbstrReturn) = 0; + virtual HRESULT __stdcall get_UserControl( + /*[out,retval]*/ VARIANT_BOOL * UserControl) = 0; + virtual HRESULT __stdcall put_UserControl( + /*[in]*/ VARIANT_BOOL UserControl) = 0; + virtual HRESULT __stdcall get_ObjectExtenders( + /*[out,retval]*/ struct ObjectExtenders * * ppObjectExtenders) = 0; + virtual HRESULT __stdcall get_Find( + /*[out,retval]*/ struct Find * * ppFind) = 0; + virtual HRESULT __stdcall get_Mode( + /*[out,retval]*/ enum vsIDEMode * pVal) = 0; + virtual HRESULT __stdcall LaunchWizard( + /*[in]*/ BSTR VSZFile, + /*[in]*/ SAFEARRAY * * ContextParams, + /*[out,retval]*/ enum wizardResult * pResult) = 0; + virtual HRESULT __stdcall get_ItemOperations( + /*[out,retval]*/ struct ItemOperations * * ppItemOperations) = 0; + virtual HRESULT __stdcall get_UndoContext( + /*[out,retval]*/ struct UndoContext * * ppUndoContext) = 0; + virtual HRESULT __stdcall get_Macros( + /*[out,retval]*/ struct Macros * * ppMacros) = 0; + virtual HRESULT __stdcall get_ActiveSolutionProjects( + /*[out,retval]*/ VARIANT * pProjects) = 0; + virtual HRESULT __stdcall get_MacrosIDE( + /*[out,retval]*/ struct _DTE * * pDTE) = 0; + virtual HRESULT __stdcall get_RegistryRoot( + /*[out,retval]*/ BSTR * pVal) = 0; + virtual HRESULT __stdcall get_Application( + /*[out,retval]*/ struct _DTE * * pVal) = 0; + virtual HRESULT __stdcall get_ContextAttributes( + /*[out,retval]*/ struct ContextAttributes * * ppVal) = 0; + virtual HRESULT __stdcall get_SourceControl( + /*[out,retval]*/ struct SourceControl * * ppVal) = 0; + virtual HRESULT __stdcall get_SuppressUI( + /*[out,retval]*/ VARIANT_BOOL * pVal) = 0; + virtual HRESULT __stdcall put_SuppressUI( + /*[in]*/ VARIANT_BOOL pVal) = 0; + virtual HRESULT __stdcall get_Debugger( + /*[out,retval]*/ struct Debugger * * ppDebugger) = 0; + virtual HRESULT __stdcall SatelliteDllPath( + BSTR Path, + BSTR Name, + /*[out,retval]*/ BSTR * pFullPath) = 0; + virtual HRESULT __stdcall get_Edition( + /*[out,retval]*/ BSTR * ProductEdition) = 0; + }; + + struct __declspec(uuid("2294311a-b7bc-4789-b365-1c15ff2cd17c")) + Windows : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall Item( + /*[in]*/ VARIANT index, + /*[out,retval]*/ struct Window * * lppcReturn) = 0; + virtual HRESULT __stdcall get_Count( + /*[out,retval]*/ long * lplReturn) = 0; + virtual HRESULT __stdcall _NewEnum( + /*[out,retval]*/ IUnknown * * lppiuReturn) = 0; + virtual HRESULT __stdcall CreateToolWindow( + /*[in]*/ struct AddIn * AddInInst, + /*[in]*/ BSTR ProgID, + /*[in]*/ BSTR Caption, + /*[in]*/ BSTR GuidPosition, + /*[in,out]*/ IDispatch * * DocObj, + /*[out,retval]*/ struct Window * * lppcReturn) = 0; + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * lppaReturn) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct _DTE * * lppaReturn) = 0; + virtual HRESULT __stdcall CreateLinkedWindowFrame( + /*[in]*/ struct Window * Window1, + /*[in]*/ struct Window * Window2, + /*[in]*/ enum vsLinkedWindowType Link, + /*[out,retval]*/ struct Window * * LinkedWindowFrame) = 0; + }; + + struct __declspec(uuid("0beab46b-4c07-4f94-a8d7-1626020e4e53")) + Window : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_Collection( + /*[out,retval]*/ struct Windows * * lppaReturn) = 0; + virtual HRESULT __stdcall get_Visible( + /*[out,retval]*/ VARIANT_BOOL * pfVisible) = 0; + virtual HRESULT __stdcall put_Visible( + /*[in]*/ VARIANT_BOOL pfVisible) = 0; + virtual HRESULT __stdcall get_Left( + /*[out,retval]*/ long * plLeft) = 0; + virtual HRESULT __stdcall put_Left( + /*[in]*/ long plLeft) = 0; + virtual HRESULT __stdcall get_Top( + /*[out,retval]*/ long * plTop) = 0; + virtual HRESULT __stdcall put_Top( + /*[in]*/ long plTop) = 0; + virtual HRESULT __stdcall get_Width( + /*[out,retval]*/ long * plWidth) = 0; + virtual HRESULT __stdcall put_Width( + /*[in]*/ long plWidth) = 0; + virtual HRESULT __stdcall get_Height( + /*[out,retval]*/ long * plHeight) = 0; + virtual HRESULT __stdcall put_Height( + /*[in]*/ long plHeight) = 0; + virtual HRESULT __stdcall get_WindowState( + /*[out,retval]*/ enum vsWindowState * plWindowState) = 0; + virtual HRESULT __stdcall put_WindowState( + /*[in]*/ enum vsWindowState plWindowState) = 0; + virtual HRESULT __stdcall SetFocus() = 0; + virtual HRESULT __stdcall get_Type( + /*[out,retval]*/ enum vsWindowType * pKind) = 0; + virtual HRESULT __stdcall SetKind( + /*[in]*/ enum vsWindowType eKind) = 0; + virtual HRESULT __stdcall get_LinkedWindows( + /*[out,retval]*/ struct LinkedWindows * * ppwnsCollection) = 0; + virtual HRESULT __stdcall get_LinkedWindowFrame( + /*[out,retval]*/ struct Window * * ppwinFrame) = 0; + virtual HRESULT __stdcall Detach() = 0; + virtual HRESULT __stdcall Attach( + /*[in]*/ long lWindowHandle) = 0; + virtual HRESULT __stdcall get_HWnd( + /*[out,retval]*/ long * plWindowHandle) = 0; + virtual HRESULT __stdcall get_Kind( + /*[out,retval]*/ BSTR * pbstrType) = 0; + virtual HRESULT __stdcall get_ObjectKind( + /*[out,retval]*/ BSTR * pbstrTypeGUID) = 0; + virtual HRESULT __stdcall get_Object( + /*[out,retval]*/ IDispatch * * ppToolObject) = 0; + virtual HRESULT __stdcall get_DocumentData( + /*[in]*/ BSTR bstrWhichData, + /*[out,retval]*/ IDispatch * * ppDataObject) = 0; + virtual HRESULT __stdcall get_ProjectItem( + /*[out,retval]*/ struct ProjectItem * * ppProjItem) = 0; + virtual HRESULT __stdcall get_Project( + /*[out,retval]*/ struct Project * * ppProj) = 0; + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * lppaReturn) = 0; + virtual HRESULT __stdcall get_Document( + /*[out,retval]*/ struct Document * * ppDocument) = 0; + virtual HRESULT __stdcall get_Selection( + /*[out,retval]*/ IDispatch * * ppDocument) = 0; + virtual HRESULT __stdcall get_Linkable( + /*[out,retval]*/ VARIANT_BOOL * pLinkable) = 0; + virtual HRESULT __stdcall put_Linkable( + /*[in]*/ VARIANT_BOOL pLinkable) = 0; + virtual HRESULT __stdcall Activate() = 0; + virtual HRESULT __stdcall Close( + /*[in]*/ enum vsSaveChanges SaveChanges) = 0; + virtual HRESULT __stdcall get_Caption( + /*[out,retval]*/ BSTR * pbstrTitle) = 0; + virtual HRESULT __stdcall put_Caption( + /*[in]*/ BSTR pbstrTitle) = 0; + virtual HRESULT __stdcall SetSelectionContainer( + SAFEARRAY * * Objects) = 0; + virtual HRESULT __stdcall get_IsFloating( + /*[out,retval]*/ VARIANT_BOOL * Floating) = 0; + virtual HRESULT __stdcall put_IsFloating( + /*[in]*/ VARIANT_BOOL Floating) = 0; + virtual HRESULT __stdcall get_AutoHides( + /*[out,retval]*/ VARIANT_BOOL * Hides) = 0; + virtual HRESULT __stdcall put_AutoHides( + /*[in]*/ VARIANT_BOOL Hides) = 0; + virtual HRESULT __stdcall SetTabPicture( + VARIANT Picture) = 0; + virtual HRESULT __stdcall get_ContextAttributes( + /*[out,retval]*/ struct ContextAttributes * * ppVal) = 0; + }; + + struct __declspec(uuid("f00ef34a-a654-4c1b-897a-585d5bcbb35a")) + LinkedWindows : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct Window * * ppptReturn) = 0; + virtual HRESULT __stdcall Item( + /*[in]*/ VARIANT index, + /*[out,retval]*/ struct Window * * lppcReturn) = 0; + virtual HRESULT __stdcall get_Count( + /*[out,retval]*/ long * lplReturn) = 0; + virtual HRESULT __stdcall _NewEnum( + /*[out,retval]*/ IUnknown * * lppiuReturn) = 0; + virtual HRESULT __stdcall Remove( + /*[in]*/ struct Window * Window) = 0; + virtual HRESULT __stdcall Add( + /*[in]*/ struct Window * Window) = 0; + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * lppaReturn) = 0; + }; + + struct __declspec(uuid("f47dc7e7-84b6-474f-bb91-631640aa0560")) + TextBuffer : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct Window * * retval) = 0; + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * lppaReturn) = 0; + virtual HRESULT __stdcall AddFromString( + /*[in]*/ BSTR String, + /*[in]*/ long StartLine) = 0; + virtual HRESULT __stdcall AddFromFile( + /*[in]*/ BSTR FileName, + /*[in]*/ long StartLine) = 0; + virtual HRESULT __stdcall get_Lines( + /*[in]*/ long StartLine, + /*[in]*/ long Count, + /*[out,retval]*/ BSTR * String) = 0; + virtual HRESULT __stdcall get_CountOfLines( + /*[out,retval]*/ long * CountOfLines) = 0; + virtual HRESULT __stdcall DeleteLines( + /*[in]*/ long StartLine, + /*[in]*/ long Count) = 0; + virtual HRESULT __stdcall Find( + /*[in]*/ BSTR Target, + /*[in,out]*/ long * StartLine, + /*[in,out]*/ long * StartColumn, + /*[in,out]*/ long * EndLine, + /*[in,out]*/ long * EndColumn, + /*[in]*/ VARIANT_BOOL WholeWord, + /*[in]*/ VARIANT_BOOL MatchCase, + /*[in]*/ VARIANT_BOOL PatternSearch, + /*[out,retval]*/ VARIANT_BOOL * pfFound) = 0; + }; + + struct __declspec(uuid("17d12026-ba99-403e-a359-71fd1e5a72cd")) + _WindowEventsRoot : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_WindowEvents( + /*[in]*/ struct Window * WindowFilter, + /*[out,retval]*/ IDispatch * * ppDisp) = 0; + }; + + struct __declspec(uuid("f6576203-fbce-477e-a66b-eda237bb68a7")) + HTMLWindow : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * ppDTE) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct Window * * ppParent) = 0; + virtual HRESULT __stdcall get_CurrentTab( + /*[out,retval]*/ enum vsHTMLTabs * pTab) = 0; + virtual HRESULT __stdcall put_CurrentTab( + /*[in]*/ enum vsHTMLTabs pTab) = 0; + virtual HRESULT __stdcall get_CurrentTabObject( + /*[out,retval]*/ IDispatch * * ppObj) = 0; + }; + + struct __declspec(uuid("0b48100a-473e-433c-ab8f-66b9739ab620")) + ProjectItem : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_IsDirty( + /*[out,retval]*/ VARIANT_BOOL * lpfReturn) = 0; + virtual HRESULT __stdcall put_IsDirty( + /*[in]*/ VARIANT_BOOL lpfReturn) = 0; + virtual HRESULT __stdcall get_FileNames( + /*[in]*/ short index, + /*[out,retval]*/ BSTR * lpbstrReturn) = 0; + virtual HRESULT __stdcall SaveAs( + /*[in]*/ BSTR NewFileName, + /*[out,retval]*/ VARIANT_BOOL * lpfReturn) = 0; + virtual HRESULT __stdcall get_FileCount( + /*[out,retval]*/ short * lpsReturn) = 0; + virtual HRESULT __stdcall get_Name( + /*[out,retval]*/ BSTR * pbstrReturn) = 0; + virtual HRESULT __stdcall put_Name( + /*[in]*/ BSTR pbstrReturn) = 0; + virtual HRESULT __stdcall get_Collection( + /*[out,retval]*/ struct ProjectItems * * lppcReturn) = 0; + virtual HRESULT __stdcall get_Properties( + /*[out,retval]*/ struct Properties * * ppObject) = 0; + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * lppaReturn) = 0; + virtual HRESULT __stdcall get_Kind( + /*[out,retval]*/ BSTR * lpbstrFileName) = 0; + virtual HRESULT __stdcall get_ProjectItems( + /*[out,retval]*/ struct ProjectItems * * lppcReturn) = 0; + virtual HRESULT __stdcall get_IsOpen( + /*[in]*/ BSTR ViewKind, + /*[out,retval]*/ VARIANT_BOOL * lpfReturn) = 0; + virtual HRESULT __stdcall Open( + /*[in]*/ BSTR ViewKind, + /*[out,retval]*/ struct Window * * lppfReturn) = 0; + virtual HRESULT __stdcall Remove() = 0; + virtual HRESULT __stdcall ExpandView() = 0; + virtual HRESULT __stdcall get_Object( + /*[out,retval]*/ IDispatch * * ProjectItemModel) = 0; + virtual HRESULT __stdcall get_Extender( + /*[in]*/ BSTR ExtenderName, + /*[out,retval]*/ IDispatch * * Extender) = 0; + virtual HRESULT __stdcall get_ExtenderNames( + /*[out,retval]*/ VARIANT * ExtenderNames) = 0; + virtual HRESULT __stdcall get_ExtenderCATID( + /*[out,retval]*/ BSTR * pRetval) = 0; + virtual HRESULT __stdcall get_Saved( + /*[out,retval]*/ VARIANT_BOOL * lpfReturn) = 0; + virtual HRESULT __stdcall put_Saved( + /*[in]*/ VARIANT_BOOL lpfReturn) = 0; + virtual HRESULT __stdcall get_ConfigurationManager( + /*[out,retval]*/ struct ConfigurationManager * * ppConfigurationManager) = 0; + virtual HRESULT __stdcall get_FileCodeModel( + /*[out,retval]*/ struct FileCodeModel * * ppFileCodeModel) = 0; + virtual HRESULT __stdcall Save( + BSTR FileName) = 0; + virtual HRESULT __stdcall get_Document( + /*[out,retval]*/ struct Document * * ppDocument) = 0; + virtual HRESULT __stdcall get_SubProject( + /*[out,retval]*/ struct Project * * ppProject) = 0; + virtual HRESULT __stdcall get_ContainingProject( + /*[out,retval]*/ struct Project * * ppProject) = 0; + virtual HRESULT __stdcall Delete() = 0; + }; + + struct __declspec(uuid("d5dbe57b-c074-4e95-b015-abeeaa391693")) + ItemOperations : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * lppaReturn) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct _DTE * * lppaReturn) = 0; + virtual HRESULT __stdcall OpenFile( + /*[in]*/ BSTR FileName, + /*[in]*/ BSTR ViewKind, + /*[out,retval]*/ struct Window * * Window) = 0; + virtual HRESULT __stdcall NewFile( + /*[in]*/ BSTR Item, + /*[in]*/ BSTR Name, + /*[in]*/ BSTR ViewKind, + /*[out,retval]*/ struct Window * * Window) = 0; + virtual HRESULT __stdcall IsFileOpen( + /*[in]*/ BSTR FileName, + /*[in]*/ BSTR ViewKind, + /*[out,retval]*/ VARIANT_BOOL * pfRetval) = 0; + virtual HRESULT __stdcall AddExistingItem( + /*[in]*/ BSTR FileName, + /*[out,retval]*/ struct ProjectItem * * ProjectItem) = 0; + virtual HRESULT __stdcall AddNewItem( + /*[in]*/ BSTR Item, + /*[in]*/ BSTR Name, + /*[out,retval]*/ struct ProjectItem * * ProjectItem) = 0; + virtual HRESULT __stdcall Navigate( + /*[in]*/ BSTR URL, + /*[in]*/ enum vsNavigateOptions Options, + /*[out,retval]*/ struct Window * * Window) = 0; + virtual HRESULT __stdcall get_PromptToSave( + /*[out,retval]*/ enum vsPromptResult * Saved) = 0; + }; + + struct __declspec(uuid("8e2f1269-185e-43c7-8899-950ad2769ccf")) + ProjectItems : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall Item( + /*[in]*/ VARIANT index, + /*[out,retval]*/ struct ProjectItem * * lppcReturn) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ IDispatch * * lppptReturn) = 0; + virtual HRESULT __stdcall get_Count( + /*[out,retval]*/ long * lplReturn) = 0; + virtual HRESULT __stdcall _NewEnum( + /*[out,retval]*/ IUnknown * * lppiuReturn) = 0; + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * lppaReturn) = 0; + virtual HRESULT __stdcall get_Kind( + /*[out,retval]*/ BSTR * lpbstrFileName) = 0; + virtual HRESULT __stdcall AddFromFile( + /*[in]*/ BSTR FileName, + /*[out,retval]*/ struct ProjectItem * * lppcReturn) = 0; + virtual HRESULT __stdcall AddFromTemplate( + /*[in]*/ BSTR FileName, + /*[in]*/ BSTR Name, + /*[out,retval]*/ struct ProjectItem * * lppcReturn) = 0; + virtual HRESULT __stdcall AddFromDirectory( + /*[in]*/ BSTR Directory, + /*[out,retval]*/ struct ProjectItem * * lppcReturn) = 0; + virtual HRESULT __stdcall get_ContainingProject( + /*[out,retval]*/ struct Project * * ppProject) = 0; + virtual HRESULT __stdcall AddFolder( + BSTR Name, + BSTR Kind, + /*[out,retval]*/ struct ProjectItem * * pProjectItem) = 0; + virtual HRESULT __stdcall AddFromFileCopy( + BSTR FilePath, + /*[out,retval]*/ struct ProjectItem * * pProjectItem) = 0; + }; + + struct __declspec(uuid("866311e6-c887-4143-9833-645f5b93f6f1")) + Project : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_Name( + /*[out,retval]*/ BSTR * lpbstrName) = 0; + virtual HRESULT __stdcall put_Name( + /*[in]*/ BSTR lpbstrName) = 0; + virtual HRESULT __stdcall get_FileName( + /*[out,retval]*/ BSTR * lpbstrReturn) = 0; + virtual HRESULT __stdcall get_IsDirty( + /*[out,retval]*/ VARIANT_BOOL * lpfReturn) = 0; + virtual HRESULT __stdcall put_IsDirty( + /*[in]*/ VARIANT_BOOL lpfReturn) = 0; + virtual HRESULT __stdcall get_Collection( + /*[out,retval]*/ struct Projects * * lppaReturn) = 0; + virtual HRESULT __stdcall SaveAs( + /*[in]*/ BSTR NewFileName) = 0; + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * lppaReturn) = 0; + virtual HRESULT __stdcall get_Kind( + /*[out,retval]*/ BSTR * lpbstrFileName) = 0; + virtual HRESULT __stdcall get_ProjectItems( + /*[out,retval]*/ struct ProjectItems * * lppcReturn) = 0; + virtual HRESULT __stdcall get_Properties( + /*[out,retval]*/ struct Properties * * ppObject) = 0; + virtual HRESULT __stdcall get_UniqueName( + /*[out,retval]*/ BSTR * lpbstrFileName) = 0; + virtual HRESULT __stdcall get_Object( + /*[out,retval]*/ IDispatch * * ProjectModel) = 0; + virtual HRESULT __stdcall get_Extender( + /*[in]*/ BSTR ExtenderName, + /*[out,retval]*/ IDispatch * * Extender) = 0; + virtual HRESULT __stdcall get_ExtenderNames( + /*[out,retval]*/ VARIANT * ExtenderNames) = 0; + virtual HRESULT __stdcall get_ExtenderCATID( + /*[out,retval]*/ BSTR * pRetval) = 0; + virtual HRESULT __stdcall get_FullName( + /*[out,retval]*/ BSTR * lpbstrReturn) = 0; + virtual HRESULT __stdcall get_Saved( + /*[out,retval]*/ VARIANT_BOOL * lpfReturn) = 0; + virtual HRESULT __stdcall put_Saved( + /*[in]*/ VARIANT_BOOL lpfReturn) = 0; + virtual HRESULT __stdcall get_ConfigurationManager( + /*[out,retval]*/ struct ConfigurationManager * * ppConfigurationManager) = 0; + virtual HRESULT __stdcall get_Globals( + /*[out,retval]*/ struct Globals * * ppGlobals) = 0; + virtual HRESULT __stdcall Save( + BSTR FileName) = 0; + virtual HRESULT __stdcall get_ParentProjectItem( + /*[out,retval]*/ struct ProjectItem * * ppParentProjectItem) = 0; + virtual HRESULT __stdcall get_CodeModel( + /*[out,retval]*/ struct CodeModel * * ppCodeModel) = 0; + virtual HRESULT __stdcall Delete() = 0; + }; + + struct __declspec(uuid("e3ec0add-31b3-461f-8303-8a5e6931257a")) + Projects : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall Item( + /*[in]*/ VARIANT index, + /*[out,retval]*/ struct Project * * lppcReturn) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct _DTE * * lppaReturn) = 0; + virtual HRESULT __stdcall get_Count( + /*[out,retval]*/ long * lplReturn) = 0; + virtual HRESULT __stdcall _NewEnum( + /*[out,retval]*/ IUnknown * * lppiuReturn) = 0; + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * lppaReturn) = 0; + virtual HRESULT __stdcall get_Properties( + /*[out,retval]*/ struct Properties * * ppObject) = 0; + virtual HRESULT __stdcall get_Kind( + /*[out,retval]*/ BSTR * lpbstrReturn) = 0; + }; + + struct __declspec(uuid("4cc8ccf5-a926-4646-b17f-b4940caed472")) + Properties : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall Item( + /*[in]*/ VARIANT index, + /*[out,retval]*/ struct Property * * lplppReturn) = 0; + virtual HRESULT __stdcall get_Application( + /*[out,retval]*/ IDispatch * * lppidReturn) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ IDispatch * * lppidReturn) = 0; + virtual HRESULT __stdcall get_Count( + /*[out,retval]*/ long * lplReturn) = 0; + virtual HRESULT __stdcall _NewEnum( + /*[out,retval]*/ IUnknown * * lppiuReturn) = 0; + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * lppaReturn) = 0; + }; + + struct __declspec(uuid("7b988e06-2581-485e-9322-04881e0600d0")) + Property : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_Value( + /*[out,retval]*/ VARIANT * lppvReturn) = 0; + virtual HRESULT __stdcall put_Value( + /*[in]*/ VARIANT lppvReturn) = 0; + virtual HRESULT __stdcall putref_Value( + /*[in]*/ VARIANT lppvReturn) = 0; + virtual HRESULT __stdcall get_IndexedValue( + /*[in]*/ VARIANT Index1, + /*[in]*/ VARIANT Index2, + /*[in]*/ VARIANT Index3, + /*[in]*/ VARIANT Index4, + /*[out,retval]*/ VARIANT * Val) = 0; + virtual HRESULT __stdcall put_IndexedValue( + /*[in]*/ VARIANT Index1, + /*[in]*/ VARIANT Index2, + /*[in]*/ VARIANT Index3, + /*[in]*/ VARIANT Index4, + /*[in]*/ VARIANT Val) = 0; + virtual HRESULT __stdcall get_NumIndices( + /*[out,retval]*/ short * lpiRetVal) = 0; + virtual HRESULT __stdcall get_Application( + /*[out,retval]*/ IDispatch * * lppidReturn) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct Properties * * lpppReturn) = 0; + virtual HRESULT __stdcall get_Name( + /*[out,retval]*/ BSTR * lpbstrReturn) = 0; + virtual HRESULT __stdcall get_Collection( + /*[out,retval]*/ struct Properties * * lpppReturn) = 0; + virtual HRESULT __stdcall get_Object( + /*[out,retval]*/ IDispatch * * lppunk) = 0; + virtual HRESULT __stdcall putref_Object( + /*[in]*/ IUnknown * lppunk) = 0; + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * lppaReturn) = 0; + }; + + struct __declspec(uuid("9043fda1-345b-4364-900f-bc8598eb8e4f")) + ConfigurationManager : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * ppDTE) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ IDispatch * * ppParent) = 0; + virtual HRESULT __stdcall _NewEnum( + /*[out,retval]*/ IUnknown * * Enumerator) = 0; + virtual HRESULT __stdcall Item( + /*[in]*/ VARIANT index, + BSTR Platform, + /*[out,retval]*/ struct Configuration * * ppOut) = 0; + virtual HRESULT __stdcall get_Count( + /*[out,retval]*/ long * pCount) = 0; + virtual HRESULT __stdcall ConfigurationRow( + BSTR Name, + /*[out,retval]*/ struct Configurations * * ppOut) = 0; + virtual HRESULT __stdcall AddConfigurationRow( + BSTR NewName, + BSTR ExistingName, + /*[in]*/ VARIANT_BOOL Propagate, + /*[out,retval]*/ struct Configurations * * ppOut) = 0; + virtual HRESULT __stdcall DeleteConfigurationRow( + BSTR Name) = 0; + virtual HRESULT __stdcall get_ConfigurationRowNames( + /*[out,retval]*/ VARIANT * pNames) = 0; + virtual HRESULT __stdcall Platform( + BSTR Name, + /*[out,retval]*/ struct Configurations * * ppOut) = 0; + virtual HRESULT __stdcall AddPlatform( + BSTR NewName, + BSTR ExistingName, + /*[in]*/ VARIANT_BOOL Propagate, + /*[out,retval]*/ struct Configurations * * ppOut) = 0; + virtual HRESULT __stdcall DeletePlatform( + BSTR Name) = 0; + virtual HRESULT __stdcall get_PlatformNames( + /*[out,retval]*/ VARIANT * pNames) = 0; + virtual HRESULT __stdcall get_SupportedPlatforms( + /*[out,retval]*/ VARIANT * pPlatforms) = 0; + virtual HRESULT __stdcall get_ActiveConfiguration( + /*[out,retval]*/ struct Configuration * * ppOut) = 0; + }; + + struct __declspec(uuid("90813589-fe21-4aa4-a2e5-053fd274e980")) + Configuration : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * ppDTE) = 0; + virtual HRESULT __stdcall get_Collection( + /*[out,retval]*/ struct ConfigurationManager * * ppConfigurationManager) = 0; + virtual HRESULT __stdcall get_ConfigurationName( + /*[out,retval]*/ BSTR * pName) = 0; + virtual HRESULT __stdcall get_PlatformName( + /*[out,retval]*/ BSTR * pName) = 0; + virtual HRESULT __stdcall get_Type( + /*[out,retval]*/ enum vsConfigurationType * pType) = 0; + virtual HRESULT __stdcall get_Owner( + /*[out,retval]*/ IDispatch * * ppOwner) = 0; + virtual HRESULT __stdcall get_Properties( + /*[out,retval]*/ struct Properties * * ppProperties) = 0; + virtual HRESULT __stdcall get_IsBuildable( + /*[out,retval]*/ VARIANT_BOOL * pBuildable) = 0; + virtual HRESULT __stdcall get_IsRunable( + /*[out,retval]*/ VARIANT_BOOL * pRunable) = 0; + virtual HRESULT __stdcall get_IsDeployable( + /*[out,retval]*/ VARIANT_BOOL * pDeployable) = 0; + virtual HRESULT __stdcall get_Object( + /*[out,retval]*/ IDispatch * * ppDisp) = 0; + virtual HRESULT __stdcall get_Extender( + /*[in]*/ BSTR ExtenderName, + /*[out,retval]*/ IDispatch * * Extender) = 0; + virtual HRESULT __stdcall get_ExtenderNames( + /*[out,retval]*/ VARIANT * ExtenderNames) = 0; + virtual HRESULT __stdcall get_ExtenderCATID( + /*[out,retval]*/ BSTR * pRetval) = 0; + virtual HRESULT __stdcall get_OutputGroups( + /*[out,retval]*/ struct OutputGroups * * ppOutputGroups) = 0; + }; + + struct __declspec(uuid("b6b4c8d6-4d27-43b9-b45c-52bd16b6ba38")) + Configurations : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * ppDTE) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ IDispatch * * ppParent) = 0; + virtual HRESULT __stdcall _NewEnum( + /*[out,retval]*/ IUnknown * * Enumerator) = 0; + virtual HRESULT __stdcall Item( + /*[in]*/ VARIANT index, + /*[out,retval]*/ struct Configuration * * ppOut) = 0; + virtual HRESULT __stdcall get_Count( + /*[out,retval]*/ long * pCount) = 0; + virtual HRESULT __stdcall get_Name( + /*[out,retval]*/ BSTR * pName) = 0; + virtual HRESULT __stdcall get_Type( + /*[out,retval]*/ enum vsConfigurationType * pType) = 0; + }; + + struct __declspec(uuid("f9fa748e-e302-44cf-891b-e263189d585e")) + OutputGroups : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * ppDTE) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct Configuration * * ppConfiguration) = 0; + virtual HRESULT __stdcall _NewEnum( + /*[out,retval]*/ IUnknown * * Enumerator) = 0; + virtual HRESULT __stdcall Item( + /*[in]*/ VARIANT index, + /*[out,retval]*/ struct OutputGroup * * ppOut) = 0; + virtual HRESULT __stdcall get_Count( + /*[out,retval]*/ long * pCount) = 0; + }; + + struct __declspec(uuid("a3a80783-875f-435b-9639-e5ce888df737")) + OutputGroup : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * ppDTE) = 0; + virtual HRESULT __stdcall get_Collection( + /*[out,retval]*/ struct OutputGroups * * ppOutputGroups) = 0; + virtual HRESULT __stdcall get_FileNames( + /*[out,retval]*/ VARIANT * pNames) = 0; + virtual HRESULT __stdcall get_FileCount( + /*[out,retval]*/ long * pCountNames) = 0; + virtual HRESULT __stdcall get_DisplayName( + /*[out,retval]*/ BSTR * pName) = 0; + virtual HRESULT __stdcall get_CanonicalName( + /*[out,retval]*/ BSTR * pName) = 0; + virtual HRESULT __stdcall get_FileURLs( + /*[out,retval]*/ VARIANT * pURLs) = 0; + virtual HRESULT __stdcall get_Description( + /*[out,retval]*/ BSTR * pDesc) = 0; + }; + + struct __declspec(uuid("0cfbc2b4-0d4e-11d3-8997-00c04f688dde")) + CodeModel : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * DTEObject) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct Project * * pProj) = 0; + virtual HRESULT __stdcall get_Language( + /*[out,retval]*/ BSTR * pLanguage) = 0; + virtual HRESULT __stdcall get_CodeElements( + /*[out,retval]*/ struct CodeElements * * ppCodeElements) = 0; + virtual HRESULT __stdcall CodeTypeFromFullName( + BSTR Name, + /*[out,retval]*/ struct CodeType * * ppCodeType) = 0; + virtual HRESULT __stdcall AddNamespace( + BSTR Name, + VARIANT Location, + VARIANT Position, + /*[out,retval]*/ struct CodeNamespace * * ppCodeNamespace) = 0; + virtual HRESULT __stdcall AddClass( + BSTR Name, + VARIANT Location, + VARIANT Position, + VARIANT Bases, + VARIANT ImplementedInterfaces, + enum vsCMAccess Access, + /*[out,retval]*/ struct CodeClass * * ppCodeClass) = 0; + virtual HRESULT __stdcall AddInterface( + BSTR Name, + VARIANT Location, + VARIANT Position, + VARIANT Bases, + enum vsCMAccess Access, + /*[out,retval]*/ struct CodeInterface * * ppCodeInterface) = 0; + virtual HRESULT __stdcall AddFunction( + BSTR Name, + VARIANT Location, + enum vsCMFunction Kind, + VARIANT Type, + VARIANT Position, + enum vsCMAccess Access, + /*[out,retval]*/ struct CodeFunction * * ppCodeFunction) = 0; + virtual HRESULT __stdcall AddVariable( + BSTR Name, + VARIANT Location, + VARIANT Type, + VARIANT Position, + enum vsCMAccess Access, + /*[out,retval]*/ struct CodeVariable * * ppCodeVariable) = 0; + virtual HRESULT __stdcall AddStruct( + BSTR Name, + VARIANT Location, + VARIANT Position, + VARIANT Bases, + VARIANT ImplementedInterfaces, + enum vsCMAccess Access, + /*[out,retval]*/ struct CodeStruct * * ppCodeStruct) = 0; + virtual HRESULT __stdcall AddEnum( + BSTR Name, + VARIANT Location, + VARIANT Position, + VARIANT Bases, + enum vsCMAccess Access, + /*[out,retval]*/ struct CodeEnum * * ppCodeEnum) = 0; + virtual HRESULT __stdcall AddDelegate( + BSTR Name, + VARIANT Location, + VARIANT Type, + VARIANT Position, + enum vsCMAccess Access, + /*[out,retval]*/ struct CodeDelegate * * ppCodeDelegate) = 0; + virtual HRESULT __stdcall AddAttribute( + BSTR Name, + VARIANT Location, + BSTR Value, + VARIANT Position, + /*[out,retval]*/ struct CodeAttribute * * ppCodeAttribute) = 0; + virtual HRESULT __stdcall Remove( + VARIANT Element) = 0; + virtual HRESULT __stdcall IsValidID( + BSTR Name, + /*[out,retval]*/ VARIANT_BOOL * pValid) = 0; + virtual HRESULT __stdcall get_IsCaseSensitive( + /*[out,retval]*/ VARIANT_BOOL * pSensitive) = 0; + virtual HRESULT __stdcall CreateCodeTypeRef( + VARIANT Type, + /*[out,retval]*/ struct CodeTypeRef * * ppCodeTypeRef) = 0; + }; + + struct __declspec(uuid("0cfbc2b5-0d4e-11d3-8997-00c04f688dde")) + CodeElements : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall _NewEnum( + /*[out,retval]*/ IUnknown * * lppiuReturn) = 0; + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * DTEObject) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ IDispatch * * ParentObject) = 0; + virtual HRESULT __stdcall Item( + VARIANT index, + /*[out,retval]*/ struct CodeElement * * ppCodeElement) = 0; + virtual HRESULT __stdcall get_Count( + /*[out,retval]*/ long * CountOfCodeElements) = 0; + virtual HRESULT __stdcall Reserved1( + VARIANT Element) = 0; + virtual HRESULT __stdcall CreateUniqueID( + /*[in]*/ BSTR Prefix, + /*[in,out]*/ BSTR * NewName, + /*[out,retval]*/ VARIANT_BOOL * pRootUnique) = 0; + }; + + struct __declspec(uuid("0cfbc2b6-0d4e-11d3-8997-00c04f688dde")) + CodeElement : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * DTEObject) = 0; + virtual HRESULT __stdcall get_Collection( + /*[out,retval]*/ struct CodeElements * * ppCollection) = 0; + virtual HRESULT __stdcall get_Name( + /*[out,retval]*/ BSTR * pVal) = 0; + virtual HRESULT __stdcall put_Name( + BSTR pVal) = 0; + virtual HRESULT __stdcall get_FullName( + /*[out,retval]*/ BSTR * pVal) = 0; + virtual HRESULT __stdcall get_ProjectItem( + /*[out,retval]*/ struct ProjectItem * * pProjItem) = 0; + virtual HRESULT __stdcall get_Kind( + /*[out,retval]*/ enum vsCMElement * pCodeEltKind) = 0; + virtual HRESULT __stdcall get_IsCodeType( + /*[out,retval]*/ VARIANT_BOOL * pIsCodeType) = 0; + virtual HRESULT __stdcall get_InfoLocation( + /*[out,retval]*/ enum vsCMInfoLocation * pInfoLocation) = 0; + virtual HRESULT __stdcall get_Children( + /*[out,retval]*/ struct CodeElements * * ppCodeElements) = 0; + virtual HRESULT __stdcall get_Language( + /*[out,retval]*/ BSTR * pLanguage) = 0; + virtual HRESULT __stdcall get_StartPoint( + /*[out,retval]*/ struct TextPoint * * ppTextPoint) = 0; + virtual HRESULT __stdcall get_EndPoint( + /*[out,retval]*/ struct TextPoint * * ppTextPoint) = 0; + virtual HRESULT __stdcall get_ExtenderNames( + /*[out,retval]*/ VARIANT * ExtenderNames) = 0; + virtual HRESULT __stdcall get_Extender( + BSTR ExtenderName, + /*[out,retval]*/ IDispatch * * Extender) = 0; + virtual HRESULT __stdcall get_ExtenderCATID( + /*[out,retval]*/ BSTR * pRetval) = 0; + virtual HRESULT __stdcall GetStartPoint( + /*[in]*/ enum vsCMPart Part, + /*[out,retval]*/ struct TextPoint * * ppTextPoint) = 0; + virtual HRESULT __stdcall GetEndPoint( + /*[in]*/ enum vsCMPart Part, + /*[out,retval]*/ struct TextPoint * * ppTextPoint) = 0; + }; + + struct __declspec(uuid("7f59e94e-4939-40d2-9f7f-b7651c25905d")) + TextPoint : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * lppaReturn) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct TextDocument * * lppaReturn) = 0; + virtual HRESULT __stdcall get_Line( + /*[out,retval]*/ long * lppaReturn) = 0; + virtual HRESULT __stdcall get_LineCharOffset( + /*[out,retval]*/ long * lppaReturn) = 0; + virtual HRESULT __stdcall get_AbsoluteCharOffset( + /*[out,retval]*/ long * lppaReturn) = 0; + virtual HRESULT __stdcall get_DisplayColumn( + /*[out,retval]*/ long * lppaReturn) = 0; + virtual HRESULT __stdcall get_AtEndOfDocument( + /*[out,retval]*/ VARIANT_BOOL * lppaReturn) = 0; + virtual HRESULT __stdcall get_AtStartOfDocument( + /*[out,retval]*/ VARIANT_BOOL * lppaReturn) = 0; + virtual HRESULT __stdcall get_AtEndOfLine( + /*[out,retval]*/ VARIANT_BOOL * lppaReturn) = 0; + virtual HRESULT __stdcall get_AtStartOfLine( + /*[out,retval]*/ VARIANT_BOOL * lppaReturn) = 0; + virtual HRESULT __stdcall get_LineLength( + /*[out,retval]*/ long * lppaReturn) = 0; + virtual HRESULT __stdcall EqualTo( + /*[in]*/ struct TextPoint * Point, + /*[out,retval]*/ VARIANT_BOOL * lppaReturn) = 0; + virtual HRESULT __stdcall LessThan( + /*[in]*/ struct TextPoint * Point, + /*[out,retval]*/ VARIANT_BOOL * lppaReturn) = 0; + virtual HRESULT __stdcall GreaterThan( + /*[in]*/ struct TextPoint * Point, + /*[out,retval]*/ VARIANT_BOOL * lppaReturn) = 0; + virtual HRESULT __stdcall TryToShow( + /*[in]*/ enum vsPaneShowHow How, + /*[in]*/ VARIANT PointOrCount, + /*[out,retval]*/ VARIANT_BOOL * pbResult) = 0; + virtual HRESULT __stdcall get_CodeElement( + /*[in]*/ enum vsCMElement Scope, + /*[out,retval]*/ struct CodeElement * * ppResult) = 0; + virtual HRESULT __stdcall CreateEditPoint( + /*[out,retval]*/ struct EditPoint * * lppaReturn) = 0; + }; + + struct __declspec(uuid("42320454-626c-4dd0-9ecb-357c4f1966d8")) + VirtualPoint : TextPoint + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_VirtualCharOffset( + /*[out,retval]*/ long * pOffset) = 0; + virtual HRESULT __stdcall get_VirtualDisplayColumn( + /*[out,retval]*/ long * lppaReturn) = 0; + }; + + struct __declspec(uuid("0cfbc2be-0d4e-11d3-8997-00c04f688dde")) + CodeAttribute : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * DTEObject) = 0; + virtual HRESULT __stdcall get_Collection( + /*[out,retval]*/ struct CodeElements * * ppCollection) = 0; + virtual HRESULT __stdcall get_Name( + /*[out,retval]*/ BSTR * pVal) = 0; + virtual HRESULT __stdcall put_Name( + BSTR pVal) = 0; + virtual HRESULT __stdcall get_FullName( + /*[out,retval]*/ BSTR * pVal) = 0; + virtual HRESULT __stdcall get_ProjectItem( + /*[out,retval]*/ struct ProjectItem * * pProjItem) = 0; + virtual HRESULT __stdcall get_Kind( + /*[out,retval]*/ enum vsCMElement * pCodeEltKind) = 0; + virtual HRESULT __stdcall get_IsCodeType( + /*[out,retval]*/ VARIANT_BOOL * pIsCodeType) = 0; + virtual HRESULT __stdcall get_InfoLocation( + /*[out,retval]*/ enum vsCMInfoLocation * pInfoLocation) = 0; + virtual HRESULT __stdcall get_Children( + /*[out,retval]*/ struct CodeElements * * ppCodeElements) = 0; + virtual HRESULT __stdcall get_Language( + /*[out,retval]*/ BSTR * pLanguage) = 0; + virtual HRESULT __stdcall get_StartPoint( + /*[out,retval]*/ struct TextPoint * * ppTextPoint) = 0; + virtual HRESULT __stdcall get_EndPoint( + /*[out,retval]*/ struct TextPoint * * ppTextPoint) = 0; + virtual HRESULT __stdcall get_ExtenderNames( + /*[out,retval]*/ VARIANT * ExtenderNames) = 0; + virtual HRESULT __stdcall get_Extender( + BSTR ExtenderName, + /*[out,retval]*/ IDispatch * * Extender) = 0; + virtual HRESULT __stdcall get_ExtenderCATID( + /*[out,retval]*/ BSTR * pRetval) = 0; + virtual HRESULT __stdcall GetStartPoint( + /*[in]*/ enum vsCMPart Part, + /*[out,retval]*/ struct TextPoint * * ppTextPoint) = 0; + virtual HRESULT __stdcall GetEndPoint( + /*[in]*/ enum vsCMPart Part, + /*[out,retval]*/ struct TextPoint * * ppTextPoint) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ IDispatch * * ppParent) = 0; + virtual HRESULT __stdcall get_Value( + /*[out,retval]*/ BSTR * pValue) = 0; + virtual HRESULT __stdcall put_Value( + BSTR pValue) = 0; + virtual HRESULT __stdcall Delete() = 0; + }; + + struct __declspec(uuid("cb218890-1382-472b-9118-782700c88115")) + TextDocument : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * ppDTE) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct Document * * ppParent) = 0; + virtual HRESULT __stdcall get_Selection( + /*[out,retval]*/ struct TextSelection * * ppSel) = 0; + virtual HRESULT __stdcall ClearBookmarks() = 0; + virtual HRESULT __stdcall MarkText( + /*[in]*/ BSTR Pattern, + /*[in]*/ long vsFindOptionsValue, + /*[out,retval]*/ VARIANT_BOOL * pbRetVal) = 0; + virtual HRESULT __stdcall ReplacePattern( + /*[in]*/ BSTR Pattern, + /*[in]*/ BSTR Replace, + /*[in]*/ long vsFindOptionsValue, + /*[in,out]*/ struct TextRanges * * Tags, + /*[out,retval]*/ VARIANT_BOOL * pbRetVal) = 0; + virtual HRESULT __stdcall CreateEditPoint( + /*[in]*/ struct TextPoint * TextPoint, + /*[out,retval]*/ struct EditPoint * * lppaReturn) = 0; + virtual HRESULT __stdcall get_StartPoint( + /*[out,retval]*/ struct TextPoint * * pStartPoint) = 0; + virtual HRESULT __stdcall get_EndPoint( + /*[out,retval]*/ struct TextPoint * * pEndPoint) = 0; + virtual HRESULT __stdcall get_Language( + /*[out,retval]*/ BSTR * pLanguage) = 0; + virtual HRESULT __stdcall put_Language( + /*[in]*/ BSTR pLanguage) = 0; + virtual HRESULT __stdcall get_Type( + /*[out,retval]*/ BSTR * pType) = 0; + virtual HRESULT __stdcall get_IndentSize( + /*[out,retval]*/ long * pSize) = 0; + virtual HRESULT __stdcall get_TabSize( + /*[out,retval]*/ long * pSize) = 0; + virtual HRESULT __stdcall ReplaceText( + /*[in]*/ BSTR FindText, + /*[in]*/ BSTR ReplaceText, + /*[in]*/ long vsFindOptionsValue, + /*[out,retval]*/ VARIANT_BOOL * pbRetVal) = 0; + virtual HRESULT __stdcall PrintOut() = 0; + }; + + struct __declspec(uuid("509b9955-7303-48c9-90d4-e165b974e6ba")) + CommandWindow : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * DTEObject) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct Window * * pParent) = 0; + virtual HRESULT __stdcall SendInput( + BSTR Command, + VARIANT_BOOL Execute) = 0; + virtual HRESULT __stdcall OutputString( + BSTR Text) = 0; + virtual HRESULT __stdcall Clear() = 0; + virtual HRESULT __stdcall get_TextDocument( + /*[out,retval]*/ struct TextDocument * * ppTextDocument) = 0; + }; + + struct __declspec(uuid("b3c38885-b288-44a8-b290-34fe63bf3c76")) + _TextEditorEventsRoot : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_TextEditorEvents( + /*[in]*/ struct TextDocument * TextDocumentFilter, + /*[out,retval]*/ IDispatch * * ppDisp) = 0; + }; + + struct __declspec(uuid("63eb5c39-ca8f-498e-9a66-6dd4a27ac95b")) + Document : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * lppaReturn) = 0; + virtual HRESULT __stdcall get_Kind( + /*[out,retval]*/ BSTR * pKind) = 0; + virtual HRESULT __stdcall get_Collection( + /*[out,retval]*/ struct Documents * * DocumentsObject) = 0; + virtual HRESULT __stdcall get_ActiveWindow( + /*[out,retval]*/ struct Window * * pWindow) = 0; + virtual HRESULT __stdcall get_FullName( + /*[out,retval]*/ BSTR * pRetval) = 0; + virtual HRESULT __stdcall get_Name( + /*[out,retval]*/ BSTR * pRetval) = 0; + virtual HRESULT __stdcall get_Path( + /*[out,retval]*/ BSTR * pRetval) = 0; + virtual HRESULT __stdcall get_ReadOnly( + /*[out,retval]*/ VARIANT_BOOL * pRetval) = 0; + virtual HRESULT __stdcall get_Saved( + /*[out,retval]*/ VARIANT_BOOL * pRetval) = 0; + virtual HRESULT __stdcall put_Saved( + /*[in]*/ VARIANT_BOOL pRetval) = 0; + virtual HRESULT __stdcall get_Windows( + /*[out,retval]*/ struct Windows * * pWindows) = 0; + virtual HRESULT __stdcall get_ProjectItem( + /*[out,retval]*/ struct ProjectItem * * pRetval) = 0; + virtual HRESULT __stdcall Activate() = 0; + virtual HRESULT __stdcall Close( + /*[in]*/ enum vsSaveChanges Save) = 0; + virtual HRESULT __stdcall NewWindow( + /*[out,retval]*/ struct Window * * pWindow) = 0; + virtual HRESULT __stdcall Redo( + /*[out,retval]*/ VARIANT_BOOL * pbRetVal) = 0; + virtual HRESULT __stdcall Undo( + /*[out,retval]*/ VARIANT_BOOL * pbRetVal) = 0; + virtual HRESULT __stdcall Save( + /*[in]*/ BSTR FileName, + /*[out,retval]*/ enum vsSaveStatus * pStatus) = 0; + virtual HRESULT __stdcall get_Selection( + /*[out,retval]*/ IDispatch * * SelectionObject) = 0; + virtual HRESULT __stdcall Object( + /*[in]*/ BSTR ModelKind, + /*[out,retval]*/ IDispatch * * DataModelObject) = 0; + virtual HRESULT __stdcall get_Extender( + /*[in]*/ BSTR ExtenderName, + /*[out,retval]*/ IDispatch * * Extender) = 0; + virtual HRESULT __stdcall get_ExtenderNames( + /*[out,retval]*/ VARIANT * ExtenderNames) = 0; + virtual HRESULT __stdcall get_ExtenderCATID( + /*[out,retval]*/ BSTR * pRetval) = 0; + virtual HRESULT __stdcall PrintOut() = 0; + virtual HRESULT __stdcall get_IndentSize( + /*[out,retval]*/ long * pSize) = 0; + virtual HRESULT __stdcall get_Language( + /*[out,retval]*/ BSTR * pLanguage) = 0; + virtual HRESULT __stdcall put_Language( + /*[in]*/ BSTR pLanguage) = 0; + virtual HRESULT __stdcall put_ReadOnly( + /*[in]*/ VARIANT_BOOL pRetval) = 0; + virtual HRESULT __stdcall get_TabSize( + /*[out,retval]*/ long * pSize) = 0; + virtual HRESULT __stdcall ClearBookmarks() = 0; + virtual HRESULT __stdcall MarkText( + /*[in]*/ BSTR Pattern, + /*[in]*/ long Flags, + /*[out,retval]*/ VARIANT_BOOL * pbRetVal) = 0; + virtual HRESULT __stdcall ReplaceText( + /*[in]*/ BSTR FindText, + /*[in]*/ BSTR ReplaceText, + /*[in]*/ long Flags, + /*[out,retval]*/ VARIANT_BOOL * pbRetVal) = 0; + virtual HRESULT __stdcall get_Type( + /*[out,retval]*/ BSTR * pType) = 0; + }; + + struct __declspec(uuid("9e2cf3ea-140f-413e-bd4b-7d46740cd2f4")) + Documents : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * DTEObject) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct _DTE * * DTEObject) = 0; + virtual HRESULT __stdcall _NewEnum( + /*[out,retval]*/ IUnknown * * Enumerator) = 0; + virtual HRESULT __stdcall Item( + /*[in]*/ VARIANT index, + /*[out,retval]*/ struct Document * * DocumentObject) = 0; + virtual HRESULT __stdcall get_Count( + /*[out,retval]*/ long * CountOfDocuments) = 0; + virtual HRESULT __stdcall Add( + /*[in]*/ BSTR Kind, + /*[out,retval]*/ struct Document * * ppDocument) = 0; + virtual HRESULT __stdcall CloseAll( + /*[in]*/ enum vsSaveChanges Save) = 0; + virtual HRESULT __stdcall SaveAll() = 0; + virtual HRESULT __stdcall Open( + BSTR PathName, + BSTR Kind, + VARIANT_BOOL ReadOnly, + /*[out,retval]*/ struct Document * * ppDocument) = 0; + }; + + struct __declspec(uuid("134170f8-93b1-42dd-9f89-a2ac7010ba07")) + Events : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_CommandBarEvents( + /*[in]*/ IDispatch * CommandBarControl, + /*[out,retval]*/ IDispatch * * prceNew) = 0; + virtual HRESULT __stdcall get_CommandEvents( + /*[in]*/ BSTR Guid, + /*[in]*/ long ID, + /*[out,retval]*/ struct _CommandEvents * * ppceNew) = 0; + virtual HRESULT __stdcall get_SelectionEvents( + /*[out,retval]*/ struct _SelectionEvents * * ppceNew) = 0; + virtual HRESULT __stdcall get_SolutionEvents( + /*[out,retval]*/ struct _SolutionEvents * * ppceNew) = 0; + virtual HRESULT __stdcall get_BuildEvents( + /*[out,retval]*/ struct _BuildEvents * * ppceNew) = 0; + virtual HRESULT __stdcall get_WindowEvents( + /*[in]*/ struct Window * WindowFilter, + /*[out,retval]*/ struct _WindowEvents * * ppceNew) = 0; + virtual HRESULT __stdcall get_OutputWindowEvents( + /*[in]*/ BSTR Pane, + /*[out,retval]*/ struct _OutputWindowEvents * * ppceNew) = 0; + virtual HRESULT __stdcall get_FindEvents( + /*[out,retval]*/ struct _FindEvents * * ppFindEvents) = 0; + virtual HRESULT __stdcall get_TaskListEvents( + /*[in]*/ BSTR Filter, + /*[out,retval]*/ struct _TaskListEvents * * ppceNew) = 0; + virtual HRESULT __stdcall get_DTEEvents( + /*[out,retval]*/ struct _DTEEvents * * ppceNew) = 0; + virtual HRESULT __stdcall get_DocumentEvents( + /*[in]*/ struct Document * Document, + /*[out,retval]*/ struct _DocumentEvents * * ppceNew) = 0; + virtual HRESULT __stdcall get_SolutionItemsEvents( + /*[out,retval]*/ struct _ProjectItemsEvents * * ppeNew) = 0; + virtual HRESULT __stdcall get_MiscFilesEvents( + /*[out,retval]*/ struct _ProjectItemsEvents * * ppeNew) = 0; + virtual HRESULT __stdcall get_DebuggerEvents( + /*[out,retval]*/ struct _DebuggerEvents * * ppeNew) = 0; + virtual HRESULT __stdcall get_TextEditorEvents( + /*[in]*/ struct TextDocument * TextDocumentFilter, + /*[out,retval]*/ struct _TextEditorEvents * * ppeNew) = 0; + virtual HRESULT __stdcall GetObject( + /*[in]*/ BSTR Name, + /*[out,retval]*/ IDispatch * * ppObject) = 0; + }; + + struct __declspec(uuid("3c536122-57b1-46de-ab34-acc524140093")) + IVsExtensibility : IUnknown + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_Properties( + /*[in]*/ struct ISupportVSProperties * pParent, + /*[in]*/ IDispatch * pdispPropObj, + /*[out]*/ struct Properties * * ppProperties) = 0; + virtual HRESULT __stdcall RunWizardFile( + /*[in]*/ BSTR bstrWizFilename, + /*[in]*/ long hwndOwner, + /*[in]*/ SAFEARRAY * * vContextParams, + /*[out,retval]*/ enum wizardResult * pResult) = 0; + virtual HRESULT __stdcall Get_TextBuffer( + /*[in]*/ IUnknown * pVsTextStream, + /*[in]*/ struct IExtensibleObjectSite * pParent, + /*[out,retval]*/ struct TextBuffer * * ppTextBuffer) = 0; + virtual HRESULT __stdcall EnterAutomationFunction() = 0; + virtual HRESULT __stdcall ExitAutomationFunction() = 0; + virtual HRESULT __stdcall IsInAutomationFunction( + /*[out,retval]*/ long * pfInAutoFunc) = 0; + virtual HRESULT __stdcall GetUserControl( + /*[out]*/ VARIANT_BOOL * fUserControl) = 0; + virtual HRESULT __stdcall SetUserControl( + /*[in]*/ VARIANT_BOOL fUserControl) = 0; + virtual HRESULT __stdcall SetUserControlUnlatched( + /*[in]*/ VARIANT_BOOL fUserControl) = 0; + virtual HRESULT __stdcall LockServer( + /*[in]*/ VARIANT_BOOL __MIDL__IVsExtensibility0000) = 0; + virtual HRESULT __stdcall GetLockCount( + /*[out,retval]*/ long * pCount) = 0; + virtual HRESULT __stdcall TestForShutdown( + /*[out,retval]*/ VARIANT_BOOL * fShutdown) = 0; + virtual HRESULT __stdcall GetGlobalsObject( + /*[in]*/ VARIANT ExtractFrom, + /*[out,retval]*/ struct Globals * * ppGlobals) = 0; + virtual HRESULT __stdcall GetConfigMgr( + /*[in]*/ IUnknown * pIVsProject, + ULONG_PTR itemid, + /*[out,retval]*/ struct ConfigurationManager * * ppCfgMgr) = 0; + virtual HRESULT __stdcall FireMacroReset() = 0; + virtual HRESULT __stdcall GetDocumentFromDocCookie( + LONG_PTR lDocCookie, + /*[out,retval]*/ struct Document * * ppDoc) = 0; + virtual HRESULT __stdcall IsMethodDisabled( + GUID * pGUID, + long dispid) = 0; + virtual HRESULT __stdcall SetSuppressUI( + VARIANT_BOOL In) = 0; + virtual HRESULT __stdcall GetSuppressUI( + VARIANT_BOOL * pOut) = 0; + }; + + struct __declspec(uuid("dc5437f4-f114-11d2-aacf-00c04f688dde")) + _DocumentEventsRoot : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DocumentEvents( + /*[in]*/ struct Document * WindowFilter, + /*[out,retval]*/ IDispatch * * ppDisp) = 0; + }; + + struct __declspec(uuid("1fa0e135-399a-4d2c-a4fe-d21e2480f921")) + TextSelection : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * ppDTE) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct TextDocument * * ppParent) = 0; + virtual HRESULT __stdcall get_AnchorPoint( + /*[out,retval]*/ struct VirtualPoint * * ppPoint) = 0; + virtual HRESULT __stdcall get_ActivePoint( + /*[out,retval]*/ struct VirtualPoint * * ppPoint) = 0; + virtual HRESULT __stdcall get_AnchorColumn( + /*[out,retval]*/ long * pColumn) = 0; + virtual HRESULT __stdcall get_BottomLine( + /*[out,retval]*/ long * pLine) = 0; + virtual HRESULT __stdcall get_BottomPoint( + /*[out,retval]*/ struct VirtualPoint * * ppPoint) = 0; + virtual HRESULT __stdcall get_CurrentColumn( + /*[out,retval]*/ long * pColumn) = 0; + virtual HRESULT __stdcall get_CurrentLine( + /*[out,retval]*/ long * pLine) = 0; + virtual HRESULT __stdcall get_IsEmpty( + /*[out,retval]*/ VARIANT_BOOL * pfEmpty) = 0; + virtual HRESULT __stdcall get_IsActiveEndGreater( + /*[out,retval]*/ VARIANT_BOOL * pfGreater) = 0; + virtual HRESULT __stdcall get_Text( + /*[out,retval]*/ BSTR * pText) = 0; + virtual HRESULT __stdcall put_Text( + /*[in]*/ BSTR pText) = 0; + virtual HRESULT __stdcall get_TopLine( + /*[out,retval]*/ long * pLine) = 0; + virtual HRESULT __stdcall get_TopPoint( + /*[out,retval]*/ struct VirtualPoint * * ppPoint) = 0; + virtual HRESULT __stdcall ChangeCase( + /*[in]*/ enum vsCaseOptions How) = 0; + virtual HRESULT __stdcall CharLeft( + /*[in]*/ VARIANT_BOOL Extend, + /*[in]*/ long Count) = 0; + virtual HRESULT __stdcall CharRight( + /*[in]*/ VARIANT_BOOL Extend, + /*[in]*/ long Count) = 0; + virtual HRESULT __stdcall ClearBookmark() = 0; + virtual HRESULT __stdcall Collapse() = 0; + virtual HRESULT __stdcall OutlineSection() = 0; + virtual HRESULT __stdcall Copy() = 0; + virtual HRESULT __stdcall Cut() = 0; + virtual HRESULT __stdcall Paste() = 0; + virtual HRESULT __stdcall Delete( + /*[in]*/ long Count) = 0; + virtual HRESULT __stdcall DeleteLeft( + /*[in]*/ long Count) = 0; + virtual HRESULT __stdcall DeleteWhitespace( + /*[in]*/ enum vsWhitespaceOptions Direction) = 0; + virtual HRESULT __stdcall EndOfLine( + /*[in]*/ VARIANT_BOOL Extend) = 0; + virtual HRESULT __stdcall StartOfLine( + /*[in]*/ enum vsStartOfLineOptions Where, + /*[in]*/ VARIANT_BOOL Extend) = 0; + virtual HRESULT __stdcall EndOfDocument( + /*[in]*/ VARIANT_BOOL Extend) = 0; + virtual HRESULT __stdcall StartOfDocument( + /*[in]*/ VARIANT_BOOL Extend) = 0; + virtual HRESULT __stdcall FindPattern( + /*[in]*/ BSTR Pattern, + /*[in]*/ long vsFindOptionsValue, + /*[in,out]*/ struct TextRanges * * Tags, + /*[out,retval]*/ VARIANT_BOOL * pfFound) = 0; + virtual HRESULT __stdcall ReplacePattern( + /*[in]*/ BSTR Pattern, + /*[in]*/ BSTR Replace, + /*[in]*/ long vsFindOptionsValue, + /*[in,out]*/ struct TextRanges * * Tags, + /*[out,retval]*/ VARIANT_BOOL * pfFound) = 0; + virtual HRESULT __stdcall FindText( + /*[in]*/ BSTR Pattern, + /*[in]*/ long vsFindOptionsValue, + /*[out,retval]*/ VARIANT_BOOL * pfFound) = 0; + virtual HRESULT __stdcall ReplaceText( + /*[in]*/ BSTR Pattern, + /*[in]*/ BSTR Replace, + /*[in]*/ long vsFindOptionsValue, + /*[out,retval]*/ VARIANT_BOOL * pfFound) = 0; + virtual HRESULT __stdcall GotoLine( + /*[in]*/ long Line, + /*[in]*/ VARIANT_BOOL Select) = 0; + virtual HRESULT __stdcall Indent( + /*[in]*/ long Count) = 0; + virtual HRESULT __stdcall Unindent( + /*[in]*/ long Count) = 0; + virtual HRESULT __stdcall Insert( + /*[in]*/ BSTR Text, + /*[in]*/ long vsInsertFlagsCollapseToEndValue) = 0; + virtual HRESULT __stdcall InsertFromFile( + /*[in]*/ BSTR File) = 0; + virtual HRESULT __stdcall LineDown( + /*[in]*/ VARIANT_BOOL Extend, + /*[in]*/ long Count) = 0; + virtual HRESULT __stdcall LineUp( + /*[in]*/ VARIANT_BOOL Extend, + /*[in]*/ long Count) = 0; + virtual HRESULT __stdcall MoveToPoint( + /*[in]*/ struct TextPoint * Point, + /*[in]*/ VARIANT_BOOL Extend) = 0; + virtual HRESULT __stdcall MoveToLineAndOffset( + /*[in]*/ long Line, + /*[in]*/ long Offset, + /*[in]*/ VARIANT_BOOL Extend) = 0; + virtual HRESULT __stdcall MoveToAbsoluteOffset( + /*[in]*/ long Offset, + /*[in]*/ VARIANT_BOOL Extend) = 0; + virtual HRESULT __stdcall NewLine( + /*[in]*/ long Count) = 0; + virtual HRESULT __stdcall SetBookmark() = 0; + virtual HRESULT __stdcall NextBookmark( + /*[out,retval]*/ VARIANT_BOOL * pbFound) = 0; + virtual HRESULT __stdcall PreviousBookmark( + /*[out,retval]*/ VARIANT_BOOL * pbFound) = 0; + virtual HRESULT __stdcall PadToColumn( + /*[in]*/ long Column) = 0; + virtual HRESULT __stdcall SmartFormat() = 0; + virtual HRESULT __stdcall SelectAll() = 0; + virtual HRESULT __stdcall SelectLine() = 0; + virtual HRESULT __stdcall SwapAnchor() = 0; + virtual HRESULT __stdcall Tabify() = 0; + virtual HRESULT __stdcall Untabify() = 0; + virtual HRESULT __stdcall WordLeft( + /*[in]*/ VARIANT_BOOL Extend, + /*[in]*/ long Count) = 0; + virtual HRESULT __stdcall WordRight( + /*[in]*/ VARIANT_BOOL Extend, + /*[in]*/ long Count) = 0; + virtual HRESULT __stdcall get_TextPane( + /*[out,retval]*/ struct TextPane * * ppPane) = 0; + virtual HRESULT __stdcall get_Mode( + /*[out,retval]*/ enum vsSelectionMode * pMode) = 0; + virtual HRESULT __stdcall put_Mode( + /*[in]*/ enum vsSelectionMode pMode) = 0; + virtual HRESULT __stdcall get_TextRanges( + /*[out,retval]*/ struct TextRanges * * ppRanges) = 0; + virtual HRESULT __stdcall Backspace( + /*[in]*/ long Count) = 0; + virtual HRESULT __stdcall Cancel() = 0; + virtual HRESULT __stdcall DestructiveInsert( + /*[in]*/ BSTR Text) = 0; + virtual HRESULT __stdcall MoveTo( + /*[in]*/ long Line, + /*[in]*/ long Column, + /*[in]*/ VARIANT_BOOL Extend) = 0; + virtual HRESULT __stdcall MoveToDisplayColumn( + /*[in]*/ long Line, + /*[in]*/ long Column, + /*[in]*/ VARIANT_BOOL Extend) = 0; + virtual HRESULT __stdcall PageUp( + /*[in]*/ VARIANT_BOOL Extend, + /*[in]*/ long Count) = 0; + virtual HRESULT __stdcall PageDown( + /*[in]*/ VARIANT_BOOL Extend, + /*[in]*/ long Count) = 0; + }; + + struct __declspec(uuid("b6422e9c-9efd-4f87-bddc-c7fd8f2fd303")) + TextRanges : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * ppDTE) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct TextDocument * * ppParent) = 0; + virtual HRESULT __stdcall get_Count( + /*[out,retval]*/ long * pCount) = 0; + virtual HRESULT __stdcall Item( + /*[in]*/ VARIANT index, + /*[out,retval]*/ struct TextRange * * ppRange) = 0; + virtual HRESULT __stdcall _NewEnum( + /*[out,retval]*/ IUnknown * * lppiuReturn) = 0; + }; + + struct __declspec(uuid("c1ffe800-028b-4475-a907-14f51f19bb7d")) + EditPoint : TextPoint + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall CharLeft( + /*[in]*/ long Count) = 0; + virtual HRESULT __stdcall CharRight( + /*[in]*/ long Count) = 0; + virtual HRESULT __stdcall EndOfLine() = 0; + virtual HRESULT __stdcall StartOfLine() = 0; + virtual HRESULT __stdcall EndOfDocument() = 0; + virtual HRESULT __stdcall StartOfDocument() = 0; + virtual HRESULT __stdcall WordLeft( + /*[in]*/ long Count) = 0; + virtual HRESULT __stdcall WordRight( + /*[in]*/ long Count) = 0; + virtual HRESULT __stdcall LineUp( + /*[in]*/ long Count) = 0; + virtual HRESULT __stdcall LineDown( + /*[in]*/ long Count) = 0; + virtual HRESULT __stdcall MoveToPoint( + /*[in]*/ struct TextPoint * Point) = 0; + virtual HRESULT __stdcall MoveToLineAndOffset( + /*[in]*/ long Line, + /*[in]*/ long Offset) = 0; + virtual HRESULT __stdcall MoveToAbsoluteOffset( + /*[in]*/ long Offset) = 0; + virtual HRESULT __stdcall SetBookmark() = 0; + virtual HRESULT __stdcall ClearBookmark() = 0; + virtual HRESULT __stdcall NextBookmark( + /*[out,retval]*/ VARIANT_BOOL * pbFound) = 0; + virtual HRESULT __stdcall PreviousBookmark( + /*[out,retval]*/ VARIANT_BOOL * pbFound) = 0; + virtual HRESULT __stdcall PadToColumn( + /*[in]*/ long Column) = 0; + virtual HRESULT __stdcall Insert( + /*[in]*/ BSTR Text) = 0; + virtual HRESULT __stdcall InsertFromFile( + /*[in]*/ BSTR File) = 0; + virtual HRESULT __stdcall GetText( + /*[in]*/ VARIANT PointOrCount, + /*[out,retval]*/ BSTR * pbstrText) = 0; + virtual HRESULT __stdcall GetLines( + /*[in]*/ long Start, + /*[in]*/ long ExclusiveEnd, + /*[out,retval]*/ BSTR * pbstrText) = 0; + virtual HRESULT __stdcall Copy( + /*[in]*/ VARIANT PointOrCount, + /*[in]*/ VARIANT_BOOL Append) = 0; + virtual HRESULT __stdcall Cut( + /*[in]*/ VARIANT PointOrCount, + /*[in]*/ VARIANT_BOOL Append) = 0; + virtual HRESULT __stdcall Delete( + /*[in]*/ VARIANT PointOrCount) = 0; + virtual HRESULT __stdcall Paste() = 0; + virtual HRESULT __stdcall ReadOnly( + /*[in]*/ VARIANT PointOrCount, + /*[out,retval]*/ VARIANT_BOOL * lfResult) = 0; + virtual HRESULT __stdcall FindPattern( + /*[in]*/ BSTR Pattern, + /*[in]*/ long vsFindOptionsValue, + /*[in,out]*/ struct EditPoint * * EndPoint, + /*[in,out]*/ struct TextRanges * * Tags, + /*[out,retval]*/ VARIANT_BOOL * pbFound) = 0; + virtual HRESULT __stdcall ReplacePattern( + /*[in]*/ struct TextPoint * Point, + /*[in]*/ BSTR Pattern, + /*[in]*/ BSTR Replace, + /*[in]*/ long vsFindOptionsValue, + /*[in,out]*/ struct TextRanges * * Tags, + /*[out,retval]*/ VARIANT_BOOL * pbFound) = 0; + virtual HRESULT __stdcall Indent( + /*[in]*/ struct TextPoint * Point, + /*[in]*/ long Count) = 0; + virtual HRESULT __stdcall Unindent( + /*[in]*/ struct TextPoint * Point, + /*[in]*/ long Count) = 0; + virtual HRESULT __stdcall SmartFormat( + /*[in]*/ struct TextPoint * Point) = 0; + virtual HRESULT __stdcall OutlineSection( + /*[in]*/ VARIANT PointOrCount) = 0; + virtual HRESULT __stdcall ReplaceText( + /*[in]*/ VARIANT PointOrCount, + /*[in]*/ BSTR Text, + /*[in]*/ long Flags) = 0; + virtual HRESULT __stdcall ChangeCase( + /*[in]*/ VARIANT PointOrCount, + /*[in]*/ enum vsCaseOptions How) = 0; + virtual HRESULT __stdcall DeleteWhitespace( + /*[in]*/ enum vsWhitespaceOptions Direction) = 0; + }; + + struct __declspec(uuid("72767524-e3b3-43d0-bb46-bbe1d556a9ff")) + TextRange : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * ppDTE) = 0; + virtual HRESULT __stdcall get_Collection( + /*[out,retval]*/ struct TextRanges * * ppParent) = 0; + virtual HRESULT __stdcall get_StartPoint( + /*[out,retval]*/ struct EditPoint * * ppPoint) = 0; + virtual HRESULT __stdcall get_EndPoint( + /*[out,retval]*/ struct EditPoint * * ppPoint) = 0; + }; + + struct __declspec(uuid("0a3bf283-05f8-4669-9bcb-a84b6423349a")) + TextPane : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * ppDTE) = 0; + virtual HRESULT __stdcall get_Collection( + /*[out,retval]*/ struct TextPanes * * ppPanes) = 0; + virtual HRESULT __stdcall get_Window( + /*[out,retval]*/ struct Window * * ppWin) = 0; + virtual HRESULT __stdcall get_Height( + /*[out,retval]*/ long * pHeight) = 0; + virtual HRESULT __stdcall get_Width( + /*[out,retval]*/ long * pWidth) = 0; + virtual HRESULT __stdcall get_Selection( + /*[out,retval]*/ struct TextSelection * * ppSel) = 0; + virtual HRESULT __stdcall get_StartPoint( + /*[out,retval]*/ struct TextPoint * * ppPoint) = 0; + virtual HRESULT __stdcall Activate() = 0; + virtual HRESULT __stdcall IsVisible( + /*[in]*/ struct TextPoint * Point, + /*[in]*/ VARIANT PointOrCount, + /*[out,retval]*/ VARIANT_BOOL * pbResult) = 0; + virtual HRESULT __stdcall TryToShow( + /*[in]*/ struct TextPoint * Point, + /*[in]*/ enum vsPaneShowHow How, + /*[in]*/ VARIANT PointOrCount, + /*[out,retval]*/ VARIANT_BOOL * pbResult) = 0; + }; + + struct __declspec(uuid("d9013d31-3652-46b2-a25a-29a881b9f86b")) + TextPanes : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * ppDTE) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct TextWindow * * ppParent) = 0; + virtual HRESULT __stdcall get_Count( + /*[out,retval]*/ long * pCount) = 0; + virtual HRESULT __stdcall Item( + /*[in]*/ VARIANT index, + /*[out,retval]*/ struct TextPane * * ppPane) = 0; + virtual HRESULT __stdcall _NewEnum( + /*[out,retval]*/ IUnknown * * lppiuReturn) = 0; + }; + + struct __declspec(uuid("2fc54dc9-922b-44eb-8cc0-ba182584dc4b")) + TextWindow : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * ppDTE) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct Window * * ppParent) = 0; + virtual HRESULT __stdcall get_Selection( + /*[out,retval]*/ struct TextSelection * * ppSel) = 0; + virtual HRESULT __stdcall get_ActivePane( + /*[out,retval]*/ struct TextPane * * ppPane) = 0; + virtual HRESULT __stdcall get_Panes( + /*[out,retval]*/ struct TextPanes * * ppPanes) = 0; + }; + + struct __declspec(uuid("0cfbc2b7-0d4e-11d3-8997-00c04f688dde")) + CodeType : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * DTEObject) = 0; + virtual HRESULT __stdcall get_Collection( + /*[out,retval]*/ struct CodeElements * * ppCollection) = 0; + virtual HRESULT __stdcall get_Name( + /*[out,retval]*/ BSTR * pVal) = 0; + virtual HRESULT __stdcall put_Name( + BSTR pVal) = 0; + virtual HRESULT __stdcall get_FullName( + /*[out,retval]*/ BSTR * pVal) = 0; + virtual HRESULT __stdcall get_ProjectItem( + /*[out,retval]*/ struct ProjectItem * * pProjItem) = 0; + virtual HRESULT __stdcall get_Kind( + /*[out,retval]*/ enum vsCMElement * pCodeEltKind) = 0; + virtual HRESULT __stdcall get_IsCodeType( + /*[out,retval]*/ VARIANT_BOOL * pIsCodeType) = 0; + virtual HRESULT __stdcall get_InfoLocation( + /*[out,retval]*/ enum vsCMInfoLocation * pInfoLocation) = 0; + virtual HRESULT __stdcall get_Children( + /*[out,retval]*/ struct CodeElements * * ppCodeElements) = 0; + virtual HRESULT __stdcall get_Language( + /*[out,retval]*/ BSTR * pLanguage) = 0; + virtual HRESULT __stdcall get_StartPoint( + /*[out,retval]*/ struct TextPoint * * ppTextPoint) = 0; + virtual HRESULT __stdcall get_EndPoint( + /*[out,retval]*/ struct TextPoint * * ppTextPoint) = 0; + virtual HRESULT __stdcall get_ExtenderNames( + /*[out,retval]*/ VARIANT * ExtenderNames) = 0; + virtual HRESULT __stdcall get_Extender( + BSTR ExtenderName, + /*[out,retval]*/ IDispatch * * Extender) = 0; + virtual HRESULT __stdcall get_ExtenderCATID( + /*[out,retval]*/ BSTR * pRetval) = 0; + virtual HRESULT __stdcall GetStartPoint( + /*[in]*/ enum vsCMPart Part, + /*[out,retval]*/ struct TextPoint * * ppTextPoint) = 0; + virtual HRESULT __stdcall GetEndPoint( + /*[in]*/ enum vsCMPart Part, + /*[out,retval]*/ struct TextPoint * * ppTextPoint) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ IDispatch * * ParentObject) = 0; + virtual HRESULT __stdcall get_Namespace( + /*[out,retval]*/ struct CodeNamespace * * ppCodeNamespace) = 0; + virtual HRESULT __stdcall get_Bases( + /*[out,retval]*/ struct CodeElements * * ppCodeElements) = 0; + virtual HRESULT __stdcall get_Members( + /*[out,retval]*/ struct CodeElements * * ppCodeElements) = 0; + virtual HRESULT __stdcall put_Access( + enum vsCMAccess pAccess) = 0; + virtual HRESULT __stdcall get_Access( + /*[out,retval]*/ enum vsCMAccess * pAccess) = 0; + virtual HRESULT __stdcall get_Attributes( + /*[out,retval]*/ struct CodeElements * * ppCodeElements) = 0; + virtual HRESULT __stdcall get_DocComment( + /*[out,retval]*/ BSTR * pDocComment) = 0; + virtual HRESULT __stdcall put_DocComment( + BSTR pDocComment) = 0; + virtual HRESULT __stdcall get_Comment( + /*[out,retval]*/ BSTR * pComment) = 0; + virtual HRESULT __stdcall put_Comment( + BSTR pComment) = 0; + virtual HRESULT __stdcall AddBase( + VARIANT Base, + VARIANT Position, + /*[out,retval]*/ struct CodeElement * * ppOut) = 0; + virtual HRESULT __stdcall AddAttribute( + BSTR Name, + BSTR Value, + VARIANT Position, + /*[out,retval]*/ struct CodeAttribute * * ppCodeAttribute) = 0; + virtual HRESULT __stdcall RemoveBase( + VARIANT Element) = 0; + virtual HRESULT __stdcall RemoveMember( + VARIANT Element) = 0; + virtual HRESULT __stdcall get_IsDerivedFrom( + BSTR FullName, + /*[out,retval]*/ VARIANT_BOOL * pVal) = 0; + virtual HRESULT __stdcall get_DerivedTypes( + /*[out,retval]*/ struct CodeElements * * ppCodeElements) = 0; + }; + + struct __declspec(uuid("0cfbc2bc-0d4e-11d3-8997-00c04f688dde")) + CodeTypeRef : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * DTEObject) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ IDispatch * * ParentObject) = 0; + virtual HRESULT __stdcall get_TypeKind( + /*[out,retval]*/ enum vsCMTypeRef * pType) = 0; + virtual HRESULT __stdcall get_CodeType( + /*[out,retval]*/ struct CodeType * * ppCodeType) = 0; + virtual HRESULT __stdcall put_CodeType( + struct CodeType * ppCodeType) = 0; + virtual HRESULT __stdcall get_ElementType( + /*[out,retval]*/ struct CodeTypeRef * * ppCodeTypeRef) = 0; + virtual HRESULT __stdcall put_ElementType( + struct CodeTypeRef * ppCodeTypeRef) = 0; + virtual HRESULT __stdcall get_AsString( + /*[out,retval]*/ BSTR * pAsString) = 0; + virtual HRESULT __stdcall get_AsFullName( + /*[out,retval]*/ BSTR * pAsFullName) = 0; + virtual HRESULT __stdcall get_Rank( + /*[out,retval]*/ long * pRank) = 0; + virtual HRESULT __stdcall put_Rank( + long pRank) = 0; + virtual HRESULT __stdcall CreateArrayType( + long Rank, + /*[out,retval]*/ struct CodeTypeRef * * ppTypeRef) = 0; + }; + + struct __declspec(uuid("0cfbc2bd-0d4e-11d3-8997-00c04f688dde")) + CodeParameter : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * DTEObject) = 0; + virtual HRESULT __stdcall get_Collection( + /*[out,retval]*/ struct CodeElements * * ppCollection) = 0; + virtual HRESULT __stdcall get_Name( + /*[out,retval]*/ BSTR * pVal) = 0; + virtual HRESULT __stdcall put_Name( + BSTR pVal) = 0; + virtual HRESULT __stdcall get_FullName( + /*[out,retval]*/ BSTR * pVal) = 0; + virtual HRESULT __stdcall get_ProjectItem( + /*[out,retval]*/ struct ProjectItem * * pProjItem) = 0; + virtual HRESULT __stdcall get_Kind( + /*[out,retval]*/ enum vsCMElement * pCodeEltKind) = 0; + virtual HRESULT __stdcall get_IsCodeType( + /*[out,retval]*/ VARIANT_BOOL * pIsCodeType) = 0; + virtual HRESULT __stdcall get_InfoLocation( + /*[out,retval]*/ enum vsCMInfoLocation * pInfoLocation) = 0; + virtual HRESULT __stdcall get_Children( + /*[out,retval]*/ struct CodeElements * * ppCodeElements) = 0; + virtual HRESULT __stdcall get_Language( + /*[out,retval]*/ BSTR * pLanguage) = 0; + virtual HRESULT __stdcall get_StartPoint( + /*[out,retval]*/ struct TextPoint * * ppTextPoint) = 0; + virtual HRESULT __stdcall get_EndPoint( + /*[out,retval]*/ struct TextPoint * * ppTextPoint) = 0; + virtual HRESULT __stdcall get_ExtenderNames( + /*[out,retval]*/ VARIANT * ExtenderNames) = 0; + virtual HRESULT __stdcall get_Extender( + BSTR ExtenderName, + /*[out,retval]*/ IDispatch * * Extender) = 0; + virtual HRESULT __stdcall get_ExtenderCATID( + /*[out,retval]*/ BSTR * pRetval) = 0; + virtual HRESULT __stdcall GetStartPoint( + /*[in]*/ enum vsCMPart Part, + /*[out,retval]*/ struct TextPoint * * ppTextPoint) = 0; + virtual HRESULT __stdcall GetEndPoint( + /*[in]*/ enum vsCMPart Part, + /*[out,retval]*/ struct TextPoint * * ppTextPoint) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct CodeElement * * ppCodeElement) = 0; + virtual HRESULT __stdcall put_Type( + struct CodeTypeRef * pCodeTypeRef) = 0; + virtual HRESULT __stdcall get_Type( + /*[out,retval]*/ struct CodeTypeRef * * pCodeTypeRef) = 0; + virtual HRESULT __stdcall get_Attributes( + /*[out,retval]*/ struct CodeElements * * ppMembers) = 0; + virtual HRESULT __stdcall get_DocComment( + /*[out,retval]*/ BSTR * pDocComment) = 0; + virtual HRESULT __stdcall put_DocComment( + BSTR pDocComment) = 0; + virtual HRESULT __stdcall AddAttribute( + BSTR Name, + BSTR Value, + VARIANT Position, + /*[out,retval]*/ struct CodeAttribute * * ppCodeAttribute) = 0; + }; + + struct __declspec(uuid("0cfbc2b9-0d4e-11d3-8997-00c04f688dde")) + CodeFunction : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * DTEObject) = 0; + virtual HRESULT __stdcall get_Collection( + /*[out,retval]*/ struct CodeElements * * ppCollection) = 0; + virtual HRESULT __stdcall get_Name( + /*[out,retval]*/ BSTR * pVal) = 0; + virtual HRESULT __stdcall put_Name( + BSTR pVal) = 0; + virtual HRESULT __stdcall get_FullName( + /*[out,retval]*/ BSTR * pVal) = 0; + virtual HRESULT __stdcall get_ProjectItem( + /*[out,retval]*/ struct ProjectItem * * pProjItem) = 0; + virtual HRESULT __stdcall get_Kind( + /*[out,retval]*/ enum vsCMElement * pCodeEltKind) = 0; + virtual HRESULT __stdcall get_IsCodeType( + /*[out,retval]*/ VARIANT_BOOL * pIsCodeType) = 0; + virtual HRESULT __stdcall get_InfoLocation( + /*[out,retval]*/ enum vsCMInfoLocation * pInfoLocation) = 0; + virtual HRESULT __stdcall get_Children( + /*[out,retval]*/ struct CodeElements * * ppCodeElements) = 0; + virtual HRESULT __stdcall get_Language( + /*[out,retval]*/ BSTR * pLanguage) = 0; + virtual HRESULT __stdcall get_StartPoint( + /*[out,retval]*/ struct TextPoint * * ppTextPoint) = 0; + virtual HRESULT __stdcall get_EndPoint( + /*[out,retval]*/ struct TextPoint * * ppTextPoint) = 0; + virtual HRESULT __stdcall get_ExtenderNames( + /*[out,retval]*/ VARIANT * ExtenderNames) = 0; + virtual HRESULT __stdcall get_Extender( + BSTR ExtenderName, + /*[out,retval]*/ IDispatch * * Extender) = 0; + virtual HRESULT __stdcall get_ExtenderCATID( + /*[out,retval]*/ BSTR * pRetval) = 0; + virtual HRESULT __stdcall GetStartPoint( + /*[in]*/ enum vsCMPart Part, + /*[out,retval]*/ struct TextPoint * * ppTextPoint) = 0; + virtual HRESULT __stdcall GetEndPoint( + /*[in]*/ enum vsCMPart Part, + /*[out,retval]*/ struct TextPoint * * ppTextPoint) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ IDispatch * * ParentObject) = 0; + virtual HRESULT __stdcall get_FunctionKind( + /*[out,retval]*/ enum vsCMFunction * ppFunctionKind) = 0; + virtual HRESULT __stdcall get_Prototype( + /*[in]*/ long Flags, + /*[out,retval]*/ BSTR * pFullName) = 0; + virtual HRESULT __stdcall get_Type( + /*[out,retval]*/ struct CodeTypeRef * * ppCodeTypeRef) = 0; + virtual HRESULT __stdcall put_Type( + struct CodeTypeRef * ppCodeTypeRef) = 0; + virtual HRESULT __stdcall get_Parameters( + /*[out,retval]*/ struct CodeElements * * ppMembers) = 0; + virtual HRESULT __stdcall put_Access( + enum vsCMAccess Access) = 0; + virtual HRESULT __stdcall get_Access( + /*[out,retval]*/ enum vsCMAccess * Access) = 0; + virtual HRESULT __stdcall get_IsOverloaded( + /*[out,retval]*/ VARIANT_BOOL * pvbOverloaded) = 0; + virtual HRESULT __stdcall get_IsShared( + /*[out,retval]*/ VARIANT_BOOL * Shared) = 0; + virtual HRESULT __stdcall put_IsShared( + VARIANT_BOOL Shared) = 0; + virtual HRESULT __stdcall get_MustImplement( + /*[out,retval]*/ VARIANT_BOOL * MustImplement) = 0; + virtual HRESULT __stdcall put_MustImplement( + VARIANT_BOOL MustImplement) = 0; + virtual HRESULT __stdcall get_Overloads( + /*[out,retval]*/ struct CodeElements * * ppMembers) = 0; + virtual HRESULT __stdcall get_Attributes( + /*[out,retval]*/ struct CodeElements * * ppMembers) = 0; + virtual HRESULT __stdcall get_DocComment( + /*[out,retval]*/ BSTR * pDocComment) = 0; + virtual HRESULT __stdcall put_DocComment( + BSTR pDocComment) = 0; + virtual HRESULT __stdcall get_Comment( + /*[out,retval]*/ BSTR * pComment) = 0; + virtual HRESULT __stdcall put_Comment( + BSTR pComment) = 0; + virtual HRESULT __stdcall AddParameter( + BSTR Name, + VARIANT Type, + VARIANT Position, + /*[out,retval]*/ struct CodeParameter * * ppCodeParameter) = 0; + virtual HRESULT __stdcall AddAttribute( + BSTR Name, + BSTR Value, + VARIANT Position, + /*[out,retval]*/ struct CodeAttribute * * ppCodeAttribute) = 0; + virtual HRESULT __stdcall RemoveParameter( + VARIANT Element) = 0; + virtual HRESULT __stdcall get_CanOverride( + /*[out,retval]*/ VARIANT_BOOL * pCanOverride) = 0; + virtual HRESULT __stdcall put_CanOverride( + VARIANT_BOOL pCanOverride) = 0; + }; + + struct __declspec(uuid("0cfbc2ba-0d4e-11d3-8997-00c04f688dde")) + CodeVariable : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * DTEObject) = 0; + virtual HRESULT __stdcall get_Collection( + /*[out,retval]*/ struct CodeElements * * ppCollection) = 0; + virtual HRESULT __stdcall get_Name( + /*[out,retval]*/ BSTR * pVal) = 0; + virtual HRESULT __stdcall put_Name( + BSTR pVal) = 0; + virtual HRESULT __stdcall get_FullName( + /*[out,retval]*/ BSTR * pVal) = 0; + virtual HRESULT __stdcall get_ProjectItem( + /*[out,retval]*/ struct ProjectItem * * pProjItem) = 0; + virtual HRESULT __stdcall get_Kind( + /*[out,retval]*/ enum vsCMElement * pCodeEltKind) = 0; + virtual HRESULT __stdcall get_IsCodeType( + /*[out,retval]*/ VARIANT_BOOL * pIsCodeType) = 0; + virtual HRESULT __stdcall get_InfoLocation( + /*[out,retval]*/ enum vsCMInfoLocation * pInfoLocation) = 0; + virtual HRESULT __stdcall get_Children( + /*[out,retval]*/ struct CodeElements * * ppCodeElements) = 0; + virtual HRESULT __stdcall get_Language( + /*[out,retval]*/ BSTR * pLanguage) = 0; + virtual HRESULT __stdcall get_StartPoint( + /*[out,retval]*/ struct TextPoint * * ppTextPoint) = 0; + virtual HRESULT __stdcall get_EndPoint( + /*[out,retval]*/ struct TextPoint * * ppTextPoint) = 0; + virtual HRESULT __stdcall get_ExtenderNames( + /*[out,retval]*/ VARIANT * ExtenderNames) = 0; + virtual HRESULT __stdcall get_Extender( + BSTR ExtenderName, + /*[out,retval]*/ IDispatch * * Extender) = 0; + virtual HRESULT __stdcall get_ExtenderCATID( + /*[out,retval]*/ BSTR * pRetval) = 0; + virtual HRESULT __stdcall GetStartPoint( + /*[in]*/ enum vsCMPart Part, + /*[out,retval]*/ struct TextPoint * * ppTextPoint) = 0; + virtual HRESULT __stdcall GetEndPoint( + /*[in]*/ enum vsCMPart Part, + /*[out,retval]*/ struct TextPoint * * ppTextPoint) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ IDispatch * * ParentObject) = 0; + virtual HRESULT __stdcall get_InitExpression( + /*[out,retval]*/ VARIANT * pExpr) = 0; + virtual HRESULT __stdcall put_InitExpression( + VARIANT pExpr) = 0; + virtual HRESULT __stdcall get_Prototype( + /*[in]*/ long Flags, + /*[out,retval]*/ BSTR * pVal) = 0; + virtual HRESULT __stdcall put_Type( + struct CodeTypeRef * pCodeTypeRef) = 0; + virtual HRESULT __stdcall get_Type( + /*[out,retval]*/ struct CodeTypeRef * * pCodeTypeRef) = 0; + virtual HRESULT __stdcall put_Access( + enum vsCMAccess Access) = 0; + virtual HRESULT __stdcall get_Access( + /*[out,retval]*/ enum vsCMAccess * Access) = 0; + virtual HRESULT __stdcall get_IsConstant( + /*[out,retval]*/ VARIANT_BOOL * pIsConstant) = 0; + virtual HRESULT __stdcall put_IsConstant( + VARIANT_BOOL pIsConstant) = 0; + virtual HRESULT __stdcall get_Attributes( + /*[out,retval]*/ struct CodeElements * * ppMembers) = 0; + virtual HRESULT __stdcall get_DocComment( + /*[out,retval]*/ BSTR * pDocComment) = 0; + virtual HRESULT __stdcall put_DocComment( + BSTR pDocComment) = 0; + virtual HRESULT __stdcall get_Comment( + /*[out,retval]*/ BSTR * pComment) = 0; + virtual HRESULT __stdcall put_Comment( + BSTR pComment) = 0; + virtual HRESULT __stdcall AddAttribute( + BSTR Name, + BSTR Value, + VARIANT Position, + /*[out,retval]*/ struct CodeAttribute * * ppCodeAttribute) = 0; + virtual HRESULT __stdcall get_IsShared( + /*[out,retval]*/ VARIANT_BOOL * pShared) = 0; + virtual HRESULT __stdcall put_IsShared( + VARIANT_BOOL pShared) = 0; + }; + + struct __declspec(uuid("0cfbc2b8-0d4e-11d3-8997-00c04f688dde")) + CodeNamespace : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * DTEObject) = 0; + virtual HRESULT __stdcall get_Collection( + /*[out,retval]*/ struct CodeElements * * ppCollection) = 0; + virtual HRESULT __stdcall get_Name( + /*[out,retval]*/ BSTR * pVal) = 0; + virtual HRESULT __stdcall put_Name( + BSTR pVal) = 0; + virtual HRESULT __stdcall get_FullName( + /*[out,retval]*/ BSTR * pVal) = 0; + virtual HRESULT __stdcall get_ProjectItem( + /*[out,retval]*/ struct ProjectItem * * pProjItem) = 0; + virtual HRESULT __stdcall get_Kind( + /*[out,retval]*/ enum vsCMElement * pCodeEltKind) = 0; + virtual HRESULT __stdcall get_IsCodeType( + /*[out,retval]*/ VARIANT_BOOL * pIsCodeType) = 0; + virtual HRESULT __stdcall get_InfoLocation( + /*[out,retval]*/ enum vsCMInfoLocation * pInfoLocation) = 0; + virtual HRESULT __stdcall get_Children( + /*[out,retval]*/ struct CodeElements * * ppCodeElements) = 0; + virtual HRESULT __stdcall get_Language( + /*[out,retval]*/ BSTR * pLanguage) = 0; + virtual HRESULT __stdcall get_StartPoint( + /*[out,retval]*/ struct TextPoint * * ppTextPoint) = 0; + virtual HRESULT __stdcall get_EndPoint( + /*[out,retval]*/ struct TextPoint * * ppTextPoint) = 0; + virtual HRESULT __stdcall get_ExtenderNames( + /*[out,retval]*/ VARIANT * ExtenderNames) = 0; + virtual HRESULT __stdcall get_Extender( + BSTR ExtenderName, + /*[out,retval]*/ IDispatch * * Extender) = 0; + virtual HRESULT __stdcall get_ExtenderCATID( + /*[out,retval]*/ BSTR * pRetval) = 0; + virtual HRESULT __stdcall GetStartPoint( + /*[in]*/ enum vsCMPart Part, + /*[out,retval]*/ struct TextPoint * * ppTextPoint) = 0; + virtual HRESULT __stdcall GetEndPoint( + /*[in]*/ enum vsCMPart Part, + /*[out,retval]*/ struct TextPoint * * ppTextPoint) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ IDispatch * * ParentObject) = 0; + virtual HRESULT __stdcall get_Members( + /*[out,retval]*/ struct CodeElements * * ppMembers) = 0; + virtual HRESULT __stdcall get_DocComment( + /*[out,retval]*/ BSTR * pDocComment) = 0; + virtual HRESULT __stdcall put_DocComment( + BSTR pDocComment) = 0; + virtual HRESULT __stdcall get_Comment( + /*[out,retval]*/ BSTR * pComment) = 0; + virtual HRESULT __stdcall put_Comment( + BSTR pComment) = 0; + virtual HRESULT __stdcall AddNamespace( + BSTR Name, + VARIANT Position, + /*[out,retval]*/ struct CodeNamespace * * ppCodeNamespace) = 0; + virtual HRESULT __stdcall AddClass( + BSTR Name, + VARIANT Position, + VARIANT Bases, + VARIANT ImplementedInterfaces, + enum vsCMAccess Access, + /*[out,retval]*/ struct CodeClass * * ppCodeClass) = 0; + virtual HRESULT __stdcall AddInterface( + BSTR Name, + VARIANT Position, + VARIANT Bases, + enum vsCMAccess Access, + /*[out,retval]*/ struct CodeInterface * * ppCodeInterface) = 0; + virtual HRESULT __stdcall AddStruct( + BSTR Name, + VARIANT Position, + VARIANT Bases, + VARIANT ImplementedInterfaces, + enum vsCMAccess Access, + /*[out,retval]*/ struct CodeStruct * * ppCodeStruct) = 0; + virtual HRESULT __stdcall AddEnum( + BSTR Name, + VARIANT Position, + VARIANT Bases, + enum vsCMAccess Access, + /*[out,retval]*/ struct CodeEnum * * ppCodeEnum) = 0; + virtual HRESULT __stdcall AddDelegate( + BSTR Name, + VARIANT Type, + VARIANT Position, + enum vsCMAccess Access, + /*[out,retval]*/ struct CodeDelegate * * ppCodeDelegate) = 0; + virtual HRESULT __stdcall Remove( + VARIANT Element) = 0; + }; + + struct __declspec(uuid("b1f42512-91cd-4d3a-8b25-a317d8032b24")) + CodeEnum : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * DTEObject) = 0; + virtual HRESULT __stdcall get_Collection( + /*[out,retval]*/ struct CodeElements * * ppCollection) = 0; + virtual HRESULT __stdcall get_Name( + /*[out,retval]*/ BSTR * pVal) = 0; + virtual HRESULT __stdcall put_Name( + BSTR pVal) = 0; + virtual HRESULT __stdcall get_FullName( + /*[out,retval]*/ BSTR * pVal) = 0; + virtual HRESULT __stdcall get_ProjectItem( + /*[out,retval]*/ struct ProjectItem * * pProjItem) = 0; + virtual HRESULT __stdcall get_Kind( + /*[out,retval]*/ enum vsCMElement * pCodeEltKind) = 0; + virtual HRESULT __stdcall get_IsCodeType( + /*[out,retval]*/ VARIANT_BOOL * pIsCodeType) = 0; + virtual HRESULT __stdcall get_InfoLocation( + /*[out,retval]*/ enum vsCMInfoLocation * pInfoLocation) = 0; + virtual HRESULT __stdcall get_Children( + /*[out,retval]*/ struct CodeElements * * ppCodeElements) = 0; + virtual HRESULT __stdcall get_Language( + /*[out,retval]*/ BSTR * pLanguage) = 0; + virtual HRESULT __stdcall get_StartPoint( + /*[out,retval]*/ struct TextPoint * * ppTextPoint) = 0; + virtual HRESULT __stdcall get_EndPoint( + /*[out,retval]*/ struct TextPoint * * ppTextPoint) = 0; + virtual HRESULT __stdcall get_ExtenderNames( + /*[out,retval]*/ VARIANT * ExtenderNames) = 0; + virtual HRESULT __stdcall get_Extender( + BSTR ExtenderName, + /*[out,retval]*/ IDispatch * * Extender) = 0; + virtual HRESULT __stdcall get_ExtenderCATID( + /*[out,retval]*/ BSTR * pRetval) = 0; + virtual HRESULT __stdcall GetStartPoint( + /*[in]*/ enum vsCMPart Part, + /*[out,retval]*/ struct TextPoint * * ppTextPoint) = 0; + virtual HRESULT __stdcall GetEndPoint( + /*[in]*/ enum vsCMPart Part, + /*[out,retval]*/ struct TextPoint * * ppTextPoint) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ IDispatch * * ParentObject) = 0; + virtual HRESULT __stdcall get_Namespace( + /*[out,retval]*/ struct CodeNamespace * * ppCodeNamespace) = 0; + virtual HRESULT __stdcall get_Bases( + /*[out,retval]*/ struct CodeElements * * ppCodeElements) = 0; + virtual HRESULT __stdcall get_Members( + /*[out,retval]*/ struct CodeElements * * ppCodeElements) = 0; + virtual HRESULT __stdcall put_Access( + enum vsCMAccess pAccess) = 0; + virtual HRESULT __stdcall get_Access( + /*[out,retval]*/ enum vsCMAccess * pAccess) = 0; + virtual HRESULT __stdcall get_Attributes( + /*[out,retval]*/ struct CodeElements * * ppCodeElements) = 0; + virtual HRESULT __stdcall get_DocComment( + /*[out,retval]*/ BSTR * pDocComment) = 0; + virtual HRESULT __stdcall put_DocComment( + BSTR pDocComment) = 0; + virtual HRESULT __stdcall get_Comment( + /*[out,retval]*/ BSTR * pComment) = 0; + virtual HRESULT __stdcall put_Comment( + BSTR pComment) = 0; + virtual HRESULT __stdcall AddBase( + VARIANT Base, + VARIANT Position, + /*[out,retval]*/ struct CodeElement * * ppOut) = 0; + virtual HRESULT __stdcall AddAttribute( + BSTR Name, + BSTR Value, + VARIANT Position, + /*[out,retval]*/ struct CodeAttribute * * ppCodeAttribute) = 0; + virtual HRESULT __stdcall RemoveBase( + VARIANT Element) = 0; + virtual HRESULT __stdcall RemoveMember( + VARIANT Element) = 0; + virtual HRESULT __stdcall get_IsDerivedFrom( + BSTR FullName, + /*[out,retval]*/ VARIANT_BOOL * pVal) = 0; + virtual HRESULT __stdcall get_DerivedTypes( + /*[out,retval]*/ struct CodeElements * * ppCodeElements) = 0; + virtual HRESULT __stdcall AddMember( + BSTR Name, + VARIANT Value, + VARIANT Position, + /*[out,retval]*/ struct CodeVariable * * ppCodeElements) = 0; + }; + + struct __declspec(uuid("b1f42514-91cd-4d3a-8b25-a317d8032b24")) + CodeClass : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * DTEObject) = 0; + virtual HRESULT __stdcall get_Collection( + /*[out,retval]*/ struct CodeElements * * ppCollection) = 0; + virtual HRESULT __stdcall get_Name( + /*[out,retval]*/ BSTR * pVal) = 0; + virtual HRESULT __stdcall put_Name( + BSTR pVal) = 0; + virtual HRESULT __stdcall get_FullName( + /*[out,retval]*/ BSTR * pVal) = 0; + virtual HRESULT __stdcall get_ProjectItem( + /*[out,retval]*/ struct ProjectItem * * pProjItem) = 0; + virtual HRESULT __stdcall get_Kind( + /*[out,retval]*/ enum vsCMElement * pCodeEltKind) = 0; + virtual HRESULT __stdcall get_IsCodeType( + /*[out,retval]*/ VARIANT_BOOL * pIsCodeType) = 0; + virtual HRESULT __stdcall get_InfoLocation( + /*[out,retval]*/ enum vsCMInfoLocation * pInfoLocation) = 0; + virtual HRESULT __stdcall get_Children( + /*[out,retval]*/ struct CodeElements * * ppCodeElements) = 0; + virtual HRESULT __stdcall get_Language( + /*[out,retval]*/ BSTR * pLanguage) = 0; + virtual HRESULT __stdcall get_StartPoint( + /*[out,retval]*/ struct TextPoint * * ppTextPoint) = 0; + virtual HRESULT __stdcall get_EndPoint( + /*[out,retval]*/ struct TextPoint * * ppTextPoint) = 0; + virtual HRESULT __stdcall get_ExtenderNames( + /*[out,retval]*/ VARIANT * ExtenderNames) = 0; + virtual HRESULT __stdcall get_Extender( + BSTR ExtenderName, + /*[out,retval]*/ IDispatch * * Extender) = 0; + virtual HRESULT __stdcall get_ExtenderCATID( + /*[out,retval]*/ BSTR * pRetval) = 0; + virtual HRESULT __stdcall GetStartPoint( + /*[in]*/ enum vsCMPart Part, + /*[out,retval]*/ struct TextPoint * * ppTextPoint) = 0; + virtual HRESULT __stdcall GetEndPoint( + /*[in]*/ enum vsCMPart Part, + /*[out,retval]*/ struct TextPoint * * ppTextPoint) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ IDispatch * * ParentObject) = 0; + virtual HRESULT __stdcall get_Namespace( + /*[out,retval]*/ struct CodeNamespace * * ppCodeNamespace) = 0; + virtual HRESULT __stdcall get_Bases( + /*[out,retval]*/ struct CodeElements * * ppCodeElements) = 0; + virtual HRESULT __stdcall get_Members( + /*[out,retval]*/ struct CodeElements * * ppCodeElements) = 0; + virtual HRESULT __stdcall put_Access( + enum vsCMAccess pAccess) = 0; + virtual HRESULT __stdcall get_Access( + /*[out,retval]*/ enum vsCMAccess * pAccess) = 0; + virtual HRESULT __stdcall get_Attributes( + /*[out,retval]*/ struct CodeElements * * ppCodeElements) = 0; + virtual HRESULT __stdcall get_DocComment( + /*[out,retval]*/ BSTR * pDocComment) = 0; + virtual HRESULT __stdcall put_DocComment( + BSTR pDocComment) = 0; + virtual HRESULT __stdcall get_Comment( + /*[out,retval]*/ BSTR * pComment) = 0; + virtual HRESULT __stdcall put_Comment( + BSTR pComment) = 0; + virtual HRESULT __stdcall AddBase( + VARIANT Base, + VARIANT Position, + /*[out,retval]*/ struct CodeElement * * ppOut) = 0; + virtual HRESULT __stdcall AddAttribute( + BSTR Name, + BSTR Value, + VARIANT Position, + /*[out,retval]*/ struct CodeAttribute * * ppCodeAttribute) = 0; + virtual HRESULT __stdcall RemoveBase( + VARIANT Element) = 0; + virtual HRESULT __stdcall RemoveMember( + VARIANT Element) = 0; + virtual HRESULT __stdcall get_IsDerivedFrom( + BSTR FullName, + /*[out,retval]*/ VARIANT_BOOL * pVal) = 0; + virtual HRESULT __stdcall get_DerivedTypes( + /*[out,retval]*/ struct CodeElements * * ppCodeElements) = 0; + virtual HRESULT __stdcall get_ImplementedInterfaces( + /*[out,retval]*/ struct CodeElements * * ppCodeElements) = 0; + virtual HRESULT __stdcall get_IsAbstract( + /*[out,retval]*/ VARIANT_BOOL * pIsAbstract) = 0; + virtual HRESULT __stdcall put_IsAbstract( + VARIANT_BOOL pIsAbstract) = 0; + virtual HRESULT __stdcall AddImplementedInterface( + VARIANT Base, + VARIANT Position, + /*[out,retval]*/ struct CodeInterface * * ppCodeInterface) = 0; + virtual HRESULT __stdcall AddFunction( + BSTR Name, + enum vsCMFunction Kind, + VARIANT Type, + VARIANT Position, + enum vsCMAccess Access, + VARIANT Location, + /*[out,retval]*/ struct CodeFunction * * ppCodeFunction) = 0; + virtual HRESULT __stdcall AddVariable( + BSTR Name, + VARIANT Type, + VARIANT Position, + enum vsCMAccess Access, + VARIANT Location, + /*[out,retval]*/ struct CodeVariable * * ppCodeVariable) = 0; + virtual HRESULT __stdcall AddProperty( + BSTR GetterName, + BSTR PutterName, + VARIANT Type, + VARIANT Position, + enum vsCMAccess Access, + VARIANT Location, + /*[out,retval]*/ struct CodeProperty * * ppCodeProperty) = 0; + virtual HRESULT __stdcall AddClass( + BSTR Name, + VARIANT Position, + VARIANT Bases, + VARIANT ImplementedInterfaces, + enum vsCMAccess Access, + /*[out,retval]*/ struct CodeClass * * ppCodeClass) = 0; + virtual HRESULT __stdcall AddStruct( + BSTR Name, + VARIANT Position, + VARIANT Bases, + VARIANT ImplementedInterfaces, + enum vsCMAccess Access, + /*[out,retval]*/ struct CodeStruct * * ppCodeStruct) = 0; + virtual HRESULT __stdcall AddEnum( + BSTR Name, + VARIANT Position, + VARIANT Bases, + enum vsCMAccess Access, + /*[out,retval]*/ struct CodeEnum * * ppCodeEnum) = 0; + virtual HRESULT __stdcall AddDelegate( + BSTR Name, + VARIANT Type, + VARIANT Position, + enum vsCMAccess Access, + /*[out,retval]*/ struct CodeDelegate * * ppCodeDelegate) = 0; + virtual HRESULT __stdcall RemoveInterface( + VARIANT Element) = 0; + }; + + struct __declspec(uuid("0cfbc2bb-0d4e-11d3-8997-00c04f688dde")) + CodeProperty : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * DTEObject) = 0; + virtual HRESULT __stdcall get_Collection( + /*[out,retval]*/ struct CodeElements * * ppCollection) = 0; + virtual HRESULT __stdcall get_Name( + /*[out,retval]*/ BSTR * pVal) = 0; + virtual HRESULT __stdcall put_Name( + BSTR pVal) = 0; + virtual HRESULT __stdcall get_FullName( + /*[out,retval]*/ BSTR * pVal) = 0; + virtual HRESULT __stdcall get_ProjectItem( + /*[out,retval]*/ struct ProjectItem * * pProjItem) = 0; + virtual HRESULT __stdcall get_Kind( + /*[out,retval]*/ enum vsCMElement * pCodeEltKind) = 0; + virtual HRESULT __stdcall get_IsCodeType( + /*[out,retval]*/ VARIANT_BOOL * pIsCodeType) = 0; + virtual HRESULT __stdcall get_InfoLocation( + /*[out,retval]*/ enum vsCMInfoLocation * pInfoLocation) = 0; + virtual HRESULT __stdcall get_Children( + /*[out,retval]*/ struct CodeElements * * ppCodeElements) = 0; + virtual HRESULT __stdcall get_Language( + /*[out,retval]*/ BSTR * pLanguage) = 0; + virtual HRESULT __stdcall get_StartPoint( + /*[out,retval]*/ struct TextPoint * * ppTextPoint) = 0; + virtual HRESULT __stdcall get_EndPoint( + /*[out,retval]*/ struct TextPoint * * ppTextPoint) = 0; + virtual HRESULT __stdcall get_ExtenderNames( + /*[out,retval]*/ VARIANT * ExtenderNames) = 0; + virtual HRESULT __stdcall get_Extender( + BSTR ExtenderName, + /*[out,retval]*/ IDispatch * * Extender) = 0; + virtual HRESULT __stdcall get_ExtenderCATID( + /*[out,retval]*/ BSTR * pRetval) = 0; + virtual HRESULT __stdcall GetStartPoint( + /*[in]*/ enum vsCMPart Part, + /*[out,retval]*/ struct TextPoint * * ppTextPoint) = 0; + virtual HRESULT __stdcall GetEndPoint( + /*[in]*/ enum vsCMPart Part, + /*[out,retval]*/ struct TextPoint * * ppTextPoint) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct CodeClass * * ParentObject) = 0; + virtual HRESULT __stdcall get_Prototype( + /*[in]*/ long Flags, + /*[out,retval]*/ BSTR * pFullName) = 0; + virtual HRESULT __stdcall put_Type( + struct CodeTypeRef * pCodeTypeRef) = 0; + virtual HRESULT __stdcall get_Type( + /*[out,retval]*/ struct CodeTypeRef * * pCodeTypeRef) = 0; + virtual HRESULT __stdcall get_Getter( + /*[out,retval]*/ struct CodeFunction * * ppCodeFunction) = 0; + virtual HRESULT __stdcall put_Getter( + struct CodeFunction * ppCodeFunction) = 0; + virtual HRESULT __stdcall get_Setter( + /*[out,retval]*/ struct CodeFunction * * ppCodeFunction) = 0; + virtual HRESULT __stdcall put_Setter( + struct CodeFunction * ppCodeFunction) = 0; + virtual HRESULT __stdcall put_Access( + enum vsCMAccess Access) = 0; + virtual HRESULT __stdcall get_Access( + /*[out,retval]*/ enum vsCMAccess * Access) = 0; + virtual HRESULT __stdcall get_Attributes( + /*[out,retval]*/ struct CodeElements * * ppMembers) = 0; + virtual HRESULT __stdcall get_DocComment( + /*[out,retval]*/ BSTR * pDocComment) = 0; + virtual HRESULT __stdcall put_DocComment( + BSTR pDocComment) = 0; + virtual HRESULT __stdcall get_Comment( + /*[out,retval]*/ BSTR * pComment) = 0; + virtual HRESULT __stdcall put_Comment( + BSTR pComment) = 0; + virtual HRESULT __stdcall AddAttribute( + BSTR Name, + BSTR Value, + VARIANT Position, + /*[out,retval]*/ struct CodeAttribute * * ppCodeAttribute) = 0; + }; + + struct __declspec(uuid("b1f42510-91cd-4d3a-8b25-a317d8032b24")) + CodeInterface : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * DTEObject) = 0; + virtual HRESULT __stdcall get_Collection( + /*[out,retval]*/ struct CodeElements * * ppCollection) = 0; + virtual HRESULT __stdcall get_Name( + /*[out,retval]*/ BSTR * pVal) = 0; + virtual HRESULT __stdcall put_Name( + BSTR pVal) = 0; + virtual HRESULT __stdcall get_FullName( + /*[out,retval]*/ BSTR * pVal) = 0; + virtual HRESULT __stdcall get_ProjectItem( + /*[out,retval]*/ struct ProjectItem * * pProjItem) = 0; + virtual HRESULT __stdcall get_Kind( + /*[out,retval]*/ enum vsCMElement * pCodeEltKind) = 0; + virtual HRESULT __stdcall get_IsCodeType( + /*[out,retval]*/ VARIANT_BOOL * pIsCodeType) = 0; + virtual HRESULT __stdcall get_InfoLocation( + /*[out,retval]*/ enum vsCMInfoLocation * pInfoLocation) = 0; + virtual HRESULT __stdcall get_Children( + /*[out,retval]*/ struct CodeElements * * ppCodeElements) = 0; + virtual HRESULT __stdcall get_Language( + /*[out,retval]*/ BSTR * pLanguage) = 0; + virtual HRESULT __stdcall get_StartPoint( + /*[out,retval]*/ struct TextPoint * * ppTextPoint) = 0; + virtual HRESULT __stdcall get_EndPoint( + /*[out,retval]*/ struct TextPoint * * ppTextPoint) = 0; + virtual HRESULT __stdcall get_ExtenderNames( + /*[out,retval]*/ VARIANT * ExtenderNames) = 0; + virtual HRESULT __stdcall get_Extender( + BSTR ExtenderName, + /*[out,retval]*/ IDispatch * * Extender) = 0; + virtual HRESULT __stdcall get_ExtenderCATID( + /*[out,retval]*/ BSTR * pRetval) = 0; + virtual HRESULT __stdcall GetStartPoint( + /*[in]*/ enum vsCMPart Part, + /*[out,retval]*/ struct TextPoint * * ppTextPoint) = 0; + virtual HRESULT __stdcall GetEndPoint( + /*[in]*/ enum vsCMPart Part, + /*[out,retval]*/ struct TextPoint * * ppTextPoint) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ IDispatch * * ParentObject) = 0; + virtual HRESULT __stdcall get_Namespace( + /*[out,retval]*/ struct CodeNamespace * * ppCodeNamespace) = 0; + virtual HRESULT __stdcall get_Bases( + /*[out,retval]*/ struct CodeElements * * ppCodeElements) = 0; + virtual HRESULT __stdcall get_Members( + /*[out,retval]*/ struct CodeElements * * ppCodeElements) = 0; + virtual HRESULT __stdcall put_Access( + enum vsCMAccess pAccess) = 0; + virtual HRESULT __stdcall get_Access( + /*[out,retval]*/ enum vsCMAccess * pAccess) = 0; + virtual HRESULT __stdcall get_Attributes( + /*[out,retval]*/ struct CodeElements * * ppCodeElements) = 0; + virtual HRESULT __stdcall get_DocComment( + /*[out,retval]*/ BSTR * pDocComment) = 0; + virtual HRESULT __stdcall put_DocComment( + BSTR pDocComment) = 0; + virtual HRESULT __stdcall get_Comment( + /*[out,retval]*/ BSTR * pComment) = 0; + virtual HRESULT __stdcall put_Comment( + BSTR pComment) = 0; + virtual HRESULT __stdcall AddBase( + VARIANT Base, + VARIANT Position, + /*[out,retval]*/ struct CodeElement * * ppOut) = 0; + virtual HRESULT __stdcall AddAttribute( + BSTR Name, + BSTR Value, + VARIANT Position, + /*[out,retval]*/ struct CodeAttribute * * ppCodeAttribute) = 0; + virtual HRESULT __stdcall RemoveBase( + VARIANT Element) = 0; + virtual HRESULT __stdcall RemoveMember( + VARIANT Element) = 0; + virtual HRESULT __stdcall get_IsDerivedFrom( + BSTR FullName, + /*[out,retval]*/ VARIANT_BOOL * pVal) = 0; + virtual HRESULT __stdcall get_DerivedTypes( + /*[out,retval]*/ struct CodeElements * * ppCodeElements) = 0; + virtual HRESULT __stdcall AddFunction( + BSTR Name, + enum vsCMFunction Kind, + VARIANT Type, + VARIANT Position, + enum vsCMAccess Access, + /*[out,retval]*/ struct CodeFunction * * ppCodeFunction) = 0; + virtual HRESULT __stdcall AddProperty( + BSTR GetterName, + BSTR PutterName, + VARIANT Type, + VARIANT Position, + enum vsCMAccess Access, + VARIANT Location, + /*[out,retval]*/ struct CodeProperty * * ppCodeProperty) = 0; + }; + + struct __declspec(uuid("b1f42513-91cd-4d3a-8b25-a317d8032b24")) + CodeDelegate : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * DTEObject) = 0; + virtual HRESULT __stdcall get_Collection( + /*[out,retval]*/ struct CodeElements * * ppCollection) = 0; + virtual HRESULT __stdcall get_Name( + /*[out,retval]*/ BSTR * pVal) = 0; + virtual HRESULT __stdcall put_Name( + BSTR pVal) = 0; + virtual HRESULT __stdcall get_FullName( + /*[out,retval]*/ BSTR * pVal) = 0; + virtual HRESULT __stdcall get_ProjectItem( + /*[out,retval]*/ struct ProjectItem * * pProjItem) = 0; + virtual HRESULT __stdcall get_Kind( + /*[out,retval]*/ enum vsCMElement * pCodeEltKind) = 0; + virtual HRESULT __stdcall get_IsCodeType( + /*[out,retval]*/ VARIANT_BOOL * pIsCodeType) = 0; + virtual HRESULT __stdcall get_InfoLocation( + /*[out,retval]*/ enum vsCMInfoLocation * pInfoLocation) = 0; + virtual HRESULT __stdcall get_Children( + /*[out,retval]*/ struct CodeElements * * ppCodeElements) = 0; + virtual HRESULT __stdcall get_Language( + /*[out,retval]*/ BSTR * pLanguage) = 0; + virtual HRESULT __stdcall get_StartPoint( + /*[out,retval]*/ struct TextPoint * * ppTextPoint) = 0; + virtual HRESULT __stdcall get_EndPoint( + /*[out,retval]*/ struct TextPoint * * ppTextPoint) = 0; + virtual HRESULT __stdcall get_ExtenderNames( + /*[out,retval]*/ VARIANT * ExtenderNames) = 0; + virtual HRESULT __stdcall get_Extender( + BSTR ExtenderName, + /*[out,retval]*/ IDispatch * * Extender) = 0; + virtual HRESULT __stdcall get_ExtenderCATID( + /*[out,retval]*/ BSTR * pRetval) = 0; + virtual HRESULT __stdcall GetStartPoint( + /*[in]*/ enum vsCMPart Part, + /*[out,retval]*/ struct TextPoint * * ppTextPoint) = 0; + virtual HRESULT __stdcall GetEndPoint( + /*[in]*/ enum vsCMPart Part, + /*[out,retval]*/ struct TextPoint * * ppTextPoint) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ IDispatch * * ParentObject) = 0; + virtual HRESULT __stdcall get_Namespace( + /*[out,retval]*/ struct CodeNamespace * * ppCodeNamespace) = 0; + virtual HRESULT __stdcall get_Bases( + /*[out,retval]*/ struct CodeElements * * ppCodeElements) = 0; + virtual HRESULT __stdcall get_Members( + /*[out,retval]*/ struct CodeElements * * ppCodeElements) = 0; + virtual HRESULT __stdcall put_Access( + enum vsCMAccess pAccess) = 0; + virtual HRESULT __stdcall get_Access( + /*[out,retval]*/ enum vsCMAccess * pAccess) = 0; + virtual HRESULT __stdcall get_Attributes( + /*[out,retval]*/ struct CodeElements * * ppCodeElements) = 0; + virtual HRESULT __stdcall get_DocComment( + /*[out,retval]*/ BSTR * pDocComment) = 0; + virtual HRESULT __stdcall put_DocComment( + BSTR pDocComment) = 0; + virtual HRESULT __stdcall get_Comment( + /*[out,retval]*/ BSTR * pComment) = 0; + virtual HRESULT __stdcall put_Comment( + BSTR pComment) = 0; + virtual HRESULT __stdcall AddBase( + VARIANT Base, + VARIANT Position, + /*[out,retval]*/ struct CodeElement * * ppOut) = 0; + virtual HRESULT __stdcall AddAttribute( + BSTR Name, + BSTR Value, + VARIANT Position, + /*[out,retval]*/ struct CodeAttribute * * ppCodeAttribute) = 0; + virtual HRESULT __stdcall RemoveBase( + VARIANT Element) = 0; + virtual HRESULT __stdcall RemoveMember( + VARIANT Element) = 0; + virtual HRESULT __stdcall get_IsDerivedFrom( + BSTR FullName, + /*[out,retval]*/ VARIANT_BOOL * pVal) = 0; + virtual HRESULT __stdcall get_DerivedTypes( + /*[out,retval]*/ struct CodeElements * * ppCodeElements) = 0; + virtual HRESULT __stdcall get_BaseClass( + /*[out,retval]*/ struct CodeClass * * ppCodeClass) = 0; + virtual HRESULT __stdcall get_Prototype( + long Flags, + /*[out,retval]*/ BSTR * pPrototype) = 0; + virtual HRESULT __stdcall get_Type( + /*[out,retval]*/ struct CodeTypeRef * * pCodeTypeRef) = 0; + virtual HRESULT __stdcall put_Type( + struct CodeTypeRef * pCodeTypeRef) = 0; + virtual HRESULT __stdcall get_Parameters( + /*[out,retval]*/ struct CodeElements * * ppParameters) = 0; + virtual HRESULT __stdcall AddParameter( + BSTR Name, + VARIANT Type, + VARIANT Position, + /*[out,retval]*/ struct CodeParameter * * ppCodeParameter) = 0; + virtual HRESULT __stdcall RemoveParameter( + VARIANT Element) = 0; + }; + + struct __declspec(uuid("b1f42511-91cd-4d3a-8b25-a317d8032b24")) + CodeStruct : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * DTEObject) = 0; + virtual HRESULT __stdcall get_Collection( + /*[out,retval]*/ struct CodeElements * * ppCollection) = 0; + virtual HRESULT __stdcall get_Name( + /*[out,retval]*/ BSTR * pVal) = 0; + virtual HRESULT __stdcall put_Name( + BSTR pVal) = 0; + virtual HRESULT __stdcall get_FullName( + /*[out,retval]*/ BSTR * pVal) = 0; + virtual HRESULT __stdcall get_ProjectItem( + /*[out,retval]*/ struct ProjectItem * * pProjItem) = 0; + virtual HRESULT __stdcall get_Kind( + /*[out,retval]*/ enum vsCMElement * pCodeEltKind) = 0; + virtual HRESULT __stdcall get_IsCodeType( + /*[out,retval]*/ VARIANT_BOOL * pIsCodeType) = 0; + virtual HRESULT __stdcall get_InfoLocation( + /*[out,retval]*/ enum vsCMInfoLocation * pInfoLocation) = 0; + virtual HRESULT __stdcall get_Children( + /*[out,retval]*/ struct CodeElements * * ppCodeElements) = 0; + virtual HRESULT __stdcall get_Language( + /*[out,retval]*/ BSTR * pLanguage) = 0; + virtual HRESULT __stdcall get_StartPoint( + /*[out,retval]*/ struct TextPoint * * ppTextPoint) = 0; + virtual HRESULT __stdcall get_EndPoint( + /*[out,retval]*/ struct TextPoint * * ppTextPoint) = 0; + virtual HRESULT __stdcall get_ExtenderNames( + /*[out,retval]*/ VARIANT * ExtenderNames) = 0; + virtual HRESULT __stdcall get_Extender( + BSTR ExtenderName, + /*[out,retval]*/ IDispatch * * Extender) = 0; + virtual HRESULT __stdcall get_ExtenderCATID( + /*[out,retval]*/ BSTR * pRetval) = 0; + virtual HRESULT __stdcall GetStartPoint( + /*[in]*/ enum vsCMPart Part, + /*[out,retval]*/ struct TextPoint * * ppTextPoint) = 0; + virtual HRESULT __stdcall GetEndPoint( + /*[in]*/ enum vsCMPart Part, + /*[out,retval]*/ struct TextPoint * * ppTextPoint) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ IDispatch * * ParentObject) = 0; + virtual HRESULT __stdcall get_Namespace( + /*[out,retval]*/ struct CodeNamespace * * ppCodeNamespace) = 0; + virtual HRESULT __stdcall get_Bases( + /*[out,retval]*/ struct CodeElements * * ppCodeElements) = 0; + virtual HRESULT __stdcall get_Members( + /*[out,retval]*/ struct CodeElements * * ppCodeElements) = 0; + virtual HRESULT __stdcall put_Access( + enum vsCMAccess pAccess) = 0; + virtual HRESULT __stdcall get_Access( + /*[out,retval]*/ enum vsCMAccess * pAccess) = 0; + virtual HRESULT __stdcall get_Attributes( + /*[out,retval]*/ struct CodeElements * * ppCodeElements) = 0; + virtual HRESULT __stdcall get_DocComment( + /*[out,retval]*/ BSTR * pDocComment) = 0; + virtual HRESULT __stdcall put_DocComment( + BSTR pDocComment) = 0; + virtual HRESULT __stdcall get_Comment( + /*[out,retval]*/ BSTR * pComment) = 0; + virtual HRESULT __stdcall put_Comment( + BSTR pComment) = 0; + virtual HRESULT __stdcall AddBase( + VARIANT Base, + VARIANT Position, + /*[out,retval]*/ struct CodeElement * * ppOut) = 0; + virtual HRESULT __stdcall AddAttribute( + BSTR Name, + BSTR Value, + VARIANT Position, + /*[out,retval]*/ struct CodeAttribute * * ppCodeAttribute) = 0; + virtual HRESULT __stdcall RemoveBase( + VARIANT Element) = 0; + virtual HRESULT __stdcall RemoveMember( + VARIANT Element) = 0; + virtual HRESULT __stdcall get_IsDerivedFrom( + BSTR FullName, + /*[out,retval]*/ VARIANT_BOOL * pVal) = 0; + virtual HRESULT __stdcall get_DerivedTypes( + /*[out,retval]*/ struct CodeElements * * ppCodeElements) = 0; + virtual HRESULT __stdcall get_ImplementedInterfaces( + /*[out,retval]*/ struct CodeElements * * ppCodeElements) = 0; + virtual HRESULT __stdcall get_IsAbstract( + /*[out,retval]*/ VARIANT_BOOL * pIsAbstract) = 0; + virtual HRESULT __stdcall put_IsAbstract( + VARIANT_BOOL pIsAbstract) = 0; + virtual HRESULT __stdcall AddImplementedInterface( + VARIANT Base, + VARIANT Position, + /*[out,retval]*/ struct CodeInterface * * ppCodeInterface) = 0; + virtual HRESULT __stdcall AddFunction( + BSTR Name, + enum vsCMFunction Kind, + VARIANT Type, + VARIANT Position, + enum vsCMAccess Access, + VARIANT Location, + /*[out,retval]*/ struct CodeFunction * * ppCodeFunction) = 0; + virtual HRESULT __stdcall AddVariable( + BSTR Name, + VARIANT Type, + VARIANT Position, + enum vsCMAccess Access, + VARIANT Location, + /*[out,retval]*/ struct CodeVariable * * ppCodeVariable) = 0; + virtual HRESULT __stdcall AddProperty( + BSTR GetterName, + BSTR PutterName, + VARIANT Type, + VARIANT Position, + enum vsCMAccess Access, + VARIANT Location, + /*[out,retval]*/ struct CodeProperty * * ppCodeProperty) = 0; + virtual HRESULT __stdcall AddClass( + BSTR Name, + VARIANT Position, + VARIANT Bases, + VARIANT ImplementedInterfaces, + enum vsCMAccess Access, + /*[out,retval]*/ struct CodeClass * * ppCodeClass) = 0; + virtual HRESULT __stdcall AddStruct( + BSTR Name, + VARIANT Position, + VARIANT Bases, + VARIANT ImplementedInterfaces, + enum vsCMAccess Access, + /*[out,retval]*/ struct CodeStruct * * ppCodeStruct) = 0; + virtual HRESULT __stdcall AddEnum( + BSTR Name, + VARIANT Position, + VARIANT Bases, + enum vsCMAccess Access, + /*[out,retval]*/ struct CodeEnum * * ppCodeEnum) = 0; + virtual HRESULT __stdcall AddDelegate( + BSTR Name, + VARIANT Type, + VARIANT Position, + enum vsCMAccess Access, + /*[out,retval]*/ struct CodeDelegate * * ppCodeDelegate) = 0; + virtual HRESULT __stdcall RemoveInterface( + VARIANT Element) = 0; + }; + + struct __declspec(uuid("ed1a3f99-4477-11d3-89bf-00c04f688dde")) + FileCodeModel : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * DTEObject) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct ProjectItem * * pProjItem) = 0; + virtual HRESULT __stdcall get_Language( + /*[out,retval]*/ BSTR * pLanguage) = 0; + virtual HRESULT __stdcall get_CodeElements( + /*[out,retval]*/ struct CodeElements * * ppCodeElements) = 0; + virtual HRESULT __stdcall CodeElementFromPoint( + struct TextPoint * Point, + enum vsCMElement Scope, + /*[out,retval]*/ struct CodeElement * * ppCodeElement) = 0; + virtual HRESULT __stdcall AddNamespace( + BSTR Name, + VARIANT Position, + /*[out,retval]*/ struct CodeNamespace * * ppCodeNamespace) = 0; + virtual HRESULT __stdcall AddClass( + BSTR Name, + VARIANT Position, + VARIANT Bases, + VARIANT ImplementedInterfaces, + enum vsCMAccess Access, + /*[out,retval]*/ struct CodeClass * * ppCodeClass) = 0; + virtual HRESULT __stdcall AddInterface( + BSTR Name, + VARIANT Position, + VARIANT Bases, + enum vsCMAccess Access, + /*[out,retval]*/ struct CodeInterface * * ppCodeInterface) = 0; + virtual HRESULT __stdcall AddFunction( + BSTR Name, + enum vsCMFunction Kind, + VARIANT Type, + VARIANT Position, + enum vsCMAccess Access, + /*[out,retval]*/ struct CodeFunction * * ppCodeFunction) = 0; + virtual HRESULT __stdcall AddVariable( + BSTR Name, + VARIANT Type, + VARIANT Position, + enum vsCMAccess Access, + /*[out,retval]*/ struct CodeVariable * * ppCodeVariable) = 0; + virtual HRESULT __stdcall AddAttribute( + BSTR Name, + BSTR Value, + VARIANT Position, + /*[out,retval]*/ struct CodeAttribute * * ppCodeAttribute) = 0; + virtual HRESULT __stdcall AddStruct( + BSTR Name, + VARIANT Position, + VARIANT Bases, + VARIANT ImplementedInterfaces, + enum vsCMAccess Access, + /*[out,retval]*/ struct CodeStruct * * ppCodeStruct) = 0; + virtual HRESULT __stdcall AddEnum( + BSTR Name, + VARIANT Position, + VARIANT Bases, + enum vsCMAccess Access, + /*[out,retval]*/ struct CodeEnum * * ppCodeEnum) = 0; + virtual HRESULT __stdcall AddDelegate( + BSTR Name, + VARIANT Type, + VARIANT Position, + enum vsCMAccess Access, + /*[out,retval]*/ struct CodeDelegate * * ppCodeDelegate) = 0; + virtual HRESULT __stdcall Remove( + VARIANT Element) = 0; + }; + + struct __declspec(uuid("33c5ebb8-244e-449d-9cee-fad70a774e59")) + ContextAttributes : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall _NewEnum( + /*[out,retval]*/ IUnknown * * lppiuReturn) = 0; + virtual HRESULT __stdcall Item( + VARIANT index, + /*[out,retval]*/ struct ContextAttribute * * ppVal) = 0; + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * lppaReturn) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ IDispatch * * lppaReturn) = 0; + virtual HRESULT __stdcall get_Count( + /*[out,retval]*/ long * Count) = 0; + virtual HRESULT __stdcall Add( + BSTR AttributeName, + BSTR AttributeValue, + enum vsContextAttributeType Type, + /*[out,retval]*/ struct ContextAttribute * * ppVal) = 0; + virtual HRESULT __stdcall get_Type( + /*[out,retval]*/ enum vsContextAttributes * Type) = 0; + virtual HRESULT __stdcall get_HighPriorityAttributes( + /*[out,retval]*/ struct ContextAttributes * * ppVal) = 0; + virtual HRESULT __stdcall Refresh() = 0; + }; + + struct __declspec(uuid("1a6e2cb3-b897-42eb-96be-ff0fdb65db2f")) + ContextAttribute : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_Name( + /*[out,retval]*/ BSTR * pName) = 0; + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * lppaReturn) = 0; + virtual HRESULT __stdcall get_Collection( + /*[out,retval]*/ struct ContextAttributes * * ppCollection) = 0; + virtual HRESULT __stdcall get_Values( + /*[out,retval]*/ VARIANT * pVal) = 0; + virtual HRESULT __stdcall Remove() = 0; + }; + + struct __declspec(uuid("53a87fa1-ce93-48bf-958b-c6da793c5028")) + AddIn : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_Description( + /*[out,retval]*/ BSTR * lpbstr) = 0; + virtual HRESULT __stdcall put_Description( + /*[in]*/ BSTR lpbstr) = 0; + virtual HRESULT __stdcall get_Collection( + /*[out,retval]*/ struct AddIns * * lppaddins) = 0; + virtual HRESULT __stdcall get_ProgID( + /*[out,retval]*/ BSTR * lpbstr) = 0; + virtual HRESULT __stdcall get_Guid( + /*[out,retval]*/ BSTR * lpbstr) = 0; + virtual HRESULT __stdcall get_Connected( + /*[out,retval]*/ VARIANT_BOOL * lpfConnect) = 0; + virtual HRESULT __stdcall put_Connected( + /*[in]*/ VARIANT_BOOL lpfConnect) = 0; + virtual HRESULT __stdcall get_Object( + /*[out,retval]*/ IDispatch * * lppdisp) = 0; + virtual HRESULT __stdcall put_Object( + /*[in]*/ IDispatch * lppdisp) = 0; + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * lppaReturn) = 0; + virtual HRESULT __stdcall get_Name( + /*[out,retval]*/ BSTR * lpbstr) = 0; + virtual HRESULT __stdcall Remove() = 0; + virtual HRESULT __stdcall get_SatelliteDllPath( + /*[out,retval]*/ BSTR * pbstrPath) = 0; + }; + + struct __declspec(uuid("50590801-d13e-4404-80c2-5ca30a4d0ee8")) + AddIns : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall Item( + /*[in]*/ VARIANT index, + /*[out,retval]*/ struct AddIn * * lppaddin) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ IDispatch * * lppaReturn) = 0; + virtual HRESULT __stdcall get_Count( + /*[out,retval]*/ long * lplReturn) = 0; + virtual HRESULT __stdcall _NewEnum( + /*[out,retval]*/ IUnknown * * lppiuReturn) = 0; + virtual HRESULT __stdcall Update() = 0; + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * lppaReturn) = 0; + virtual HRESULT __stdcall Add( + BSTR ProgID, + BSTR Description, + BSTR Name, + VARIANT_BOOL Connected, + /*[out,retval]*/ struct AddIn * * __MIDL__AddIns0000) = 0; + }; + + struct __declspec(uuid("ffc9dfc4-61ca-4b0c-83c2-0703a24f5c16")) + OutputWindowPane : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_Name( + /*[out,retval]*/ BSTR * pName) = 0; + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * pDTE) = 0; + virtual HRESULT __stdcall get_Collection( + /*[out,retval]*/ struct OutputWindowPanes * * pOutputWindowPanes) = 0; + virtual HRESULT __stdcall get_Guid( + /*[out,retval]*/ BSTR * pGUID) = 0; + virtual HRESULT __stdcall OutputString( + /*[in]*/ BSTR Text) = 0; + virtual HRESULT __stdcall ForceItemsToTaskList() = 0; + virtual HRESULT __stdcall Activate() = 0; + virtual HRESULT __stdcall Clear() = 0; + virtual HRESULT __stdcall OutputTaskItemString( + /*[in]*/ BSTR Text, + /*[in]*/ enum vsTaskPriority Priority, + /*[in]*/ BSTR SubCategory, + /*[in]*/ enum vsTaskIcon Icon, + /*[in]*/ BSTR FileName, + /*[in]*/ long Line, + /*[in]*/ BSTR Description, + /*[in]*/ VARIANT_BOOL Force) = 0; + virtual HRESULT __stdcall get_TextDocument( + /*[out,retval]*/ struct TextDocument * * pDocument) = 0; + }; + + struct __declspec(uuid("b02cf62a-9470-4308-a521-9675fba395ab")) + OutputWindowPanes : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * pDTE) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct OutputWindow * * pOutputWindow) = 0; + virtual HRESULT __stdcall get_Count( + /*[out,retval]*/ long * pCount) = 0; + virtual HRESULT __stdcall Add( + /*[in]*/ BSTR Name, + /*[out,retval]*/ struct OutputWindowPane * * pOutputWindowPane) = 0; + virtual HRESULT __stdcall Item( + VARIANT index, + /*[out,retval]*/ struct OutputWindowPane * * pOutputWindowPane) = 0; + virtual HRESULT __stdcall _NewEnum( + /*[out,retval]*/ IUnknown * * lppiuReturn) = 0; + }; + + struct __declspec(uuid("eab0a63d-c3a8-496e-9acf-a82cef6a43b3")) + OutputWindow : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * pDTE) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct Window * * pParent) = 0; + virtual HRESULT __stdcall get_OutputWindowPanes( + /*[out,retval]*/ struct OutputWindowPanes * * pOutputWindowPanes) = 0; + virtual HRESULT __stdcall get_ActivePane( + /*[out,retval]*/ struct OutputWindowPane * * pOutputWindowPane) = 0; + }; + + struct __declspec(uuid("58e4d419-6b8c-4c63-92de-70161cd95890")) + TaskItem : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * pDTE) = 0; + virtual HRESULT __stdcall get_Collection( + /*[out,retval]*/ struct TaskItems * * pTaskItems) = 0; + virtual HRESULT __stdcall get_Category( + /*[out,retval]*/ BSTR * pCategory) = 0; + virtual HRESULT __stdcall get_SubCategory( + /*[out,retval]*/ BSTR * pSubCategory) = 0; + virtual HRESULT __stdcall get_Priority( + /*[out,retval]*/ enum vsTaskPriority * pPriority) = 0; + virtual HRESULT __stdcall put_Priority( + /*[in]*/ enum vsTaskPriority pPriority) = 0; + virtual HRESULT __stdcall get_Description( + /*[out,retval]*/ BSTR * pDescription) = 0; + virtual HRESULT __stdcall put_Description( + /*[in]*/ BSTR pDescription) = 0; + virtual HRESULT __stdcall get_FileName( + /*[out,retval]*/ BSTR * pFileName) = 0; + virtual HRESULT __stdcall put_FileName( + /*[in]*/ BSTR pFileName) = 0; + virtual HRESULT __stdcall get_IsSettable( + /*[in]*/ enum vsTaskListColumn Column, + /*[out,retval]*/ VARIANT_BOOL * pSettable) = 0; + virtual HRESULT __stdcall get_Line( + /*[out,retval]*/ long * pLine) = 0; + virtual HRESULT __stdcall put_Line( + /*[in]*/ long pLine) = 0; + virtual HRESULT __stdcall get_Displayed( + /*[out,retval]*/ VARIANT_BOOL * pDisplayed) = 0; + virtual HRESULT __stdcall get_Checked( + /*[out,retval]*/ VARIANT_BOOL * pChecked) = 0; + virtual HRESULT __stdcall put_Checked( + /*[in]*/ VARIANT_BOOL pChecked) = 0; + virtual HRESULT __stdcall Navigate() = 0; + virtual HRESULT __stdcall Delete() = 0; + virtual HRESULT __stdcall Select() = 0; + }; + + struct __declspec(uuid("4b51103d-513c-4773-b56a-354d0928fd04")) + TaskItems : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * pDTE) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct TaskList * * pTaskList) = 0; + virtual HRESULT __stdcall Item( + /*[in]*/ VARIANT index, + /*[out,retval]*/ struct TaskItem * * pTaskItem) = 0; + virtual HRESULT __stdcall get_Count( + /*[out,retval]*/ long * pCount) = 0; + virtual HRESULT __stdcall Add( + /*[in]*/ BSTR Category, + /*[in]*/ BSTR SubCategory, + /*[in]*/ BSTR Description, + /*[in]*/ enum vsTaskPriority Priority, + /*[in]*/ VARIANT Icon, + /*[in]*/ VARIANT_BOOL Checkable, + /*[in]*/ BSTR File, + /*[in]*/ long Line, + /*[in]*/ VARIANT_BOOL CanUserDelete, + /*[in]*/ VARIANT_BOOL FlushItem, + /*[out,retval]*/ struct TaskItem * * pTaskItem) = 0; + virtual HRESULT __stdcall _NewEnum( + /*[out,retval]*/ IUnknown * * lppiuReturn) = 0; + virtual HRESULT __stdcall ForceItemsToTaskList() = 0; + }; + + struct __declspec(uuid("4e4f0569-e16a-4da1-92de-10882a4ddd8c")) + TaskList : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * lppReturn) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct Window * * lppReturn) = 0; + virtual HRESULT __stdcall get_DefaultCommentToken( + /*[out,retval]*/ BSTR * pbstrToken) = 0; + virtual HRESULT __stdcall get_TaskItems( + /*[out,retval]*/ struct TaskItems * * pTaskItems) = 0; + virtual HRESULT __stdcall get_SelectedItems( + /*[out,retval]*/ VARIANT * Selections) = 0; + }; + + struct __declspec(uuid("5c5a0070-f396-4e37-a82a-1b767e272df9")) + Process : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall Attach() = 0; + virtual HRESULT __stdcall Detach( + /*[in]*/ VARIANT_BOOL WaitForBreakOrEnd) = 0; + virtual HRESULT __stdcall Break( + /*[in]*/ VARIANT_BOOL WaitForBreakMode) = 0; + virtual HRESULT __stdcall Terminate( + /*[in]*/ VARIANT_BOOL WaitForBreakOrEnd) = 0; + virtual HRESULT __stdcall get_Name( + /*[out,retval]*/ BSTR * Name) = 0; + virtual HRESULT __stdcall get_ProcessID( + /*[out,retval]*/ long * ID) = 0; + virtual HRESULT __stdcall get_Programs( + /*[out,retval]*/ struct Programs * * Programs) = 0; + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * DTE) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct Debugger * * Debugger) = 0; + virtual HRESULT __stdcall get_Collection( + /*[out,retval]*/ struct Processes * * Processes) = 0; + }; + + struct __declspec(uuid("dc6a118a-bbab-11d2-8ad1-00c04f79e479")) + Programs : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall Item( + /*[in]*/ VARIANT index, + /*[out,retval]*/ struct Program * * Program) = 0; + virtual HRESULT __stdcall _NewEnum( + /*[out,retval]*/ IUnknown * * Enumerator) = 0; + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * DTEObject) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct Debugger * * Debugger) = 0; + virtual HRESULT __stdcall get_Count( + /*[out,retval]*/ long * Count) = 0; + }; + + struct __declspec(uuid("6a38d87c-bba0-11d2-8ad1-00c04f79e479")) + Program : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_Name( + /*[out,retval]*/ BSTR * Name) = 0; + virtual HRESULT __stdcall get_Process( + /*[out,retval]*/ struct Process * * Process) = 0; + virtual HRESULT __stdcall get_Threads( + /*[out,retval]*/ struct Threads * * Threads) = 0; + virtual HRESULT __stdcall get_IsBeingDebugged( + /*[out,retval]*/ VARIANT_BOOL * IsBeingDebugged) = 0; + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * DTE) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct Debugger * * Debugger) = 0; + virtual HRESULT __stdcall get_Collection( + /*[out,retval]*/ struct Programs * * Programs) = 0; + }; + + struct __declspec(uuid("6aa23fb4-bba1-11d2-8ad1-00c04f79e479")) + Threads : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall Item( + /*[in]*/ VARIANT index, + /*[out,retval]*/ struct Thread * * Thread) = 0; + virtual HRESULT __stdcall _NewEnum( + /*[out,retval]*/ IUnknown * * Enumerator) = 0; + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * DTEObject) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct Debugger * * Debugger) = 0; + virtual HRESULT __stdcall get_Count( + /*[out,retval]*/ long * Count) = 0; + }; + + struct __declspec(uuid("9407f466-bba1-11d2-8ad1-00c04f79e479")) + Thread : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall Freeze() = 0; + virtual HRESULT __stdcall Thaw() = 0; + virtual HRESULT __stdcall get_Name( + /*[out,retval]*/ BSTR * Name) = 0; + virtual HRESULT __stdcall get_SuspendCount( + /*[out,retval]*/ long * Count) = 0; + virtual HRESULT __stdcall get_ID( + /*[out,retval]*/ long * ID) = 0; + virtual HRESULT __stdcall get_StackFrames( + /*[out,retval]*/ struct StackFrames * * StackFrames) = 0; + virtual HRESULT __stdcall get_Program( + /*[out,retval]*/ struct Program * * Program) = 0; + virtual HRESULT __stdcall get_IsAlive( + /*[out,retval]*/ VARIANT_BOOL * IsAlive) = 0; + virtual HRESULT __stdcall get_Priority( + /*[out,retval]*/ BSTR * Priority) = 0; + virtual HRESULT __stdcall get_Location( + /*[out,retval]*/ BSTR * Location) = 0; + virtual HRESULT __stdcall get_IsFrozen( + /*[out,retval]*/ VARIANT_BOOL * IsFrozen) = 0; + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * DTE) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct Debugger * * Debugger) = 0; + virtual HRESULT __stdcall get_Collection( + /*[out,retval]*/ struct Threads * * Threads) = 0; + }; + + struct __declspec(uuid("4ed85664-bba2-11d2-8ad1-00c04f79e479")) + StackFrames : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall Item( + /*[in]*/ VARIANT index, + /*[out,retval]*/ struct StackFrame * * StackFrame) = 0; + virtual HRESULT __stdcall _NewEnum( + /*[out,retval]*/ IUnknown * * Enumerator) = 0; + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * DTEObject) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct Debugger * * Debugger) = 0; + virtual HRESULT __stdcall get_Count( + /*[out,retval]*/ long * Count) = 0; + }; + + struct __declspec(uuid("1342d0d8-bba3-11d2-8ad1-00c04f79e479")) + StackFrame : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_Language( + /*[out,retval]*/ BSTR * Language) = 0; + virtual HRESULT __stdcall get_FunctionName( + /*[out,retval]*/ BSTR * FunctionName) = 0; + virtual HRESULT __stdcall get_ReturnType( + /*[out,retval]*/ BSTR * ReturnType) = 0; + virtual HRESULT __stdcall get_Locals( + /*[out,retval]*/ struct Expressions * * Expressions) = 0; + virtual HRESULT __stdcall get_Arguments( + /*[out,retval]*/ struct Expressions * * Expressions) = 0; + virtual HRESULT __stdcall get_Module( + /*[out,retval]*/ BSTR * Module) = 0; + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * DTE) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct Thread * * Thread) = 0; + virtual HRESULT __stdcall get_Collection( + /*[out,retval]*/ struct StackFrames * * StackFrames) = 0; + }; + + struct __declspec(uuid("2685337a-bb9e-11d2-8ad1-00c04f79e479")) + Expressions : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall Item( + /*[in]*/ VARIANT index, + /*[out,retval]*/ struct Expression * * Expression) = 0; + virtual HRESULT __stdcall _NewEnum( + /*[out,retval]*/ IUnknown * * Enumerator) = 0; + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * DTEObject) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct Debugger * * Debugger) = 0; + virtual HRESULT __stdcall get_Count( + /*[out,retval]*/ long * Count) = 0; + }; + + struct __declspec(uuid("27adc812-bb07-11d2-8ad1-00c04f79e479")) + Expression : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_Name( + /*[out,retval]*/ BSTR * Name) = 0; + virtual HRESULT __stdcall get_Type( + /*[out,retval]*/ BSTR * Type) = 0; + virtual HRESULT __stdcall get_DataMembers( + /*[out,retval]*/ struct Expressions * * Expressions) = 0; + virtual HRESULT __stdcall get_Value( + /*[out,retval]*/ BSTR * Value) = 0; + virtual HRESULT __stdcall put_Value( + /*[in]*/ BSTR Value) = 0; + virtual HRESULT __stdcall get_IsValidValue( + /*[out,retval]*/ VARIANT_BOOL * ValidValue) = 0; + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * DTE) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct Debugger * * Debugger) = 0; + virtual HRESULT __stdcall get_Collection( + /*[out,retval]*/ struct Expressions * * Expressions) = 0; + }; + + struct __declspec(uuid("338fb9a0-bae5-11d2-8ad1-00c04f79e479")) + Debugger : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall GetExpression( + /*[in]*/ BSTR ExpressionText, + /*[in]*/ VARIANT_BOOL UseAutoExpandRules, + /*[in]*/ long Timeout, + /*[out,retval]*/ struct Expression * * Expression) = 0; + virtual HRESULT __stdcall DetachAll() = 0; + virtual HRESULT __stdcall StepInto( + /*[in]*/ VARIANT_BOOL WaitForBreakOrEnd) = 0; + virtual HRESULT __stdcall StepOver( + /*[in]*/ VARIANT_BOOL WaitForBreakOrEnd) = 0; + virtual HRESULT __stdcall StepOut( + /*[in]*/ VARIANT_BOOL WaitForBreakOrEnd) = 0; + virtual HRESULT __stdcall Go( + /*[in]*/ VARIANT_BOOL WaitForBreakOrEnd) = 0; + virtual HRESULT __stdcall Break( + /*[in]*/ VARIANT_BOOL WaitForBreakMode) = 0; + virtual HRESULT __stdcall Stop( + /*[in]*/ VARIANT_BOOL WaitForDesignMode) = 0; + virtual HRESULT __stdcall SetNextStatement() = 0; + virtual HRESULT __stdcall RunToCursor( + /*[in]*/ VARIANT_BOOL WaitForBreakOrEnd) = 0; + virtual HRESULT __stdcall ExecuteStatement( + /*[in]*/ BSTR Statement, + /*[in]*/ long Timeout, + /*[in]*/ VARIANT_BOOL TreatAsExpression) = 0; + virtual HRESULT __stdcall get_Breakpoints( + /*[out,retval]*/ struct Breakpoints * * Breakpoints) = 0; + virtual HRESULT __stdcall get_Languages( + /*[out,retval]*/ struct Languages * * Languages) = 0; + virtual HRESULT __stdcall get_CurrentMode( + /*[out,retval]*/ enum dbgDebugMode * Mode) = 0; + virtual HRESULT __stdcall get_CurrentProcess( + /*[out,retval]*/ struct Process * * Process) = 0; + virtual HRESULT __stdcall put_CurrentProcess( + /*[in]*/ struct Process * Process) = 0; + virtual HRESULT __stdcall get_CurrentProgram( + /*[out,retval]*/ struct Program * * Program) = 0; + virtual HRESULT __stdcall put_CurrentProgram( + /*[in]*/ struct Program * Program) = 0; + virtual HRESULT __stdcall get_CurrentThread( + /*[out,retval]*/ struct Thread * * Thread) = 0; + virtual HRESULT __stdcall put_CurrentThread( + /*[in]*/ struct Thread * Thread) = 0; + virtual HRESULT __stdcall get_CurrentStackFrame( + /*[out,retval]*/ struct StackFrame * * StackFrame) = 0; + virtual HRESULT __stdcall put_CurrentStackFrame( + /*[in]*/ struct StackFrame * StackFrame) = 0; + virtual HRESULT __stdcall get_HexDisplayMode( + /*[out,retval]*/ VARIANT_BOOL * HexModeOn) = 0; + virtual HRESULT __stdcall put_HexDisplayMode( + /*[in]*/ VARIANT_BOOL HexModeOn) = 0; + virtual HRESULT __stdcall get_HexInputMode( + /*[out,retval]*/ VARIANT_BOOL * HexModeOn) = 0; + virtual HRESULT __stdcall put_HexInputMode( + /*[in]*/ VARIANT_BOOL HexModeOn) = 0; + virtual HRESULT __stdcall get_LastBreakReason( + /*[out,retval]*/ enum dbgEventReason * Reason) = 0; + virtual HRESULT __stdcall get_BreakpointLastHit( + /*[out,retval]*/ struct Breakpoint * * Breakpoint) = 0; + virtual HRESULT __stdcall get_AllBreakpointsLastHit( + /*[out,retval]*/ struct Breakpoints * * Breakpoints) = 0; + virtual HRESULT __stdcall get_DebuggedProcesses( + /*[out,retval]*/ struct Processes * * Processes) = 0; + virtual HRESULT __stdcall get_LocalProcesses( + /*[out,retval]*/ struct Processes * * Processes) = 0; + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * DTE) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct _DTE * * DTE) = 0; + virtual HRESULT __stdcall TerminateAll() = 0; + }; + + struct __declspec(uuid("9f379969-5eac-4a54-b2bc-6946cffb56ef")) + Processes : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall Item( + /*[in]*/ VARIANT index, + /*[out,retval]*/ struct Process * * Process) = 0; + virtual HRESULT __stdcall _NewEnum( + /*[out,retval]*/ IUnknown * * Enumerator) = 0; + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * DTEObject) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct Debugger * * Debugger) = 0; + virtual HRESULT __stdcall get_Count( + /*[out,retval]*/ long * Count) = 0; + }; + + struct __declspec(uuid("25968106-bafb-11d2-8ad1-00c04f79e479")) + Breakpoints : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall Item( + /*[in]*/ VARIANT index, + /*[out,retval]*/ struct Breakpoint * * Breakpoint) = 0; + virtual HRESULT __stdcall _NewEnum( + /*[out,retval]*/ IUnknown * * Enumerator) = 0; + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * DTEObject) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct Debugger * * Debugger) = 0; + virtual HRESULT __stdcall get_Count( + /*[out,retval]*/ long * Count) = 0; + virtual HRESULT __stdcall Add( + /*[in]*/ BSTR Function, + /*[in]*/ BSTR File, + /*[in]*/ long Line, + /*[in]*/ long Column, + /*[in]*/ BSTR Condition, + /*[in]*/ enum dbgBreakpointConditionType ConditionType, + /*[in]*/ BSTR Language, + /*[in]*/ BSTR Data, + /*[in]*/ long DataCount, + /*[in]*/ BSTR Address, + /*[in]*/ long HitCount, + /*[in]*/ enum dbgHitCountType HitCountType, + /*[out,retval]*/ struct Breakpoints * * Breakpoints) = 0; + }; + + struct __declspec(uuid("11c5114c-bb00-11d2-8ad1-00c04f79e479")) + Breakpoint : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall Delete() = 0; + virtual HRESULT __stdcall get_Type( + /*[out,retval]*/ enum dbgBreakpointType * Type) = 0; + virtual HRESULT __stdcall get_Name( + /*[out,retval]*/ BSTR * Name) = 0; + virtual HRESULT __stdcall put_Name( + /*[in]*/ BSTR Name) = 0; + virtual HRESULT __stdcall get_LocationType( + /*[out,retval]*/ enum dbgBreakpointLocationType * LocationType) = 0; + virtual HRESULT __stdcall get_FunctionName( + /*[out,retval]*/ BSTR * FunctionName) = 0; + virtual HRESULT __stdcall get_FunctionLineOffset( + /*[out,retval]*/ long * Offset) = 0; + virtual HRESULT __stdcall get_FunctionColumnOffset( + /*[out,retval]*/ long * Offset) = 0; + virtual HRESULT __stdcall get_File( + /*[out,retval]*/ BSTR * File) = 0; + virtual HRESULT __stdcall get_FileLine( + /*[out,retval]*/ long * Line) = 0; + virtual HRESULT __stdcall get_FileColumn( + /*[out,retval]*/ long * Column) = 0; + virtual HRESULT __stdcall get_ConditionType( + /*[out,retval]*/ enum dbgBreakpointConditionType * ConditionType) = 0; + virtual HRESULT __stdcall get_Condition( + /*[out,retval]*/ BSTR * Condition) = 0; + virtual HRESULT __stdcall get_Language( + /*[out,retval]*/ BSTR * Language) = 0; + virtual HRESULT __stdcall get_HitCountType( + /*[out,retval]*/ enum dbgHitCountType * HitCountType) = 0; + virtual HRESULT __stdcall get_HitCountTarget( + /*[out,retval]*/ long * HitCountTarget) = 0; + virtual HRESULT __stdcall get_Enabled( + /*[out,retval]*/ VARIANT_BOOL * Enabled) = 0; + virtual HRESULT __stdcall put_Enabled( + /*[in]*/ VARIANT_BOOL Enabled) = 0; + virtual HRESULT __stdcall get_Tag( + /*[out,retval]*/ BSTR * Tag) = 0; + virtual HRESULT __stdcall put_Tag( + /*[in]*/ BSTR Tag) = 0; + virtual HRESULT __stdcall get_CurrentHits( + /*[out,retval]*/ long * CurHitCount) = 0; + virtual HRESULT __stdcall get_Program( + /*[out,retval]*/ struct Program * * Program) = 0; + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * DTE) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct Breakpoint * * Breakpoint) = 0; + virtual HRESULT __stdcall get_Collection( + /*[out,retval]*/ struct Breakpoints * * Breakpoints) = 0; + virtual HRESULT __stdcall get_Children( + /*[out,retval]*/ struct Breakpoints * * Breakpoints) = 0; + virtual HRESULT __stdcall ResetHitCount() = 0; + }; + + struct __declspec(uuid("a4f4246c-c131-11d2-8ad1-00c04f79e479")) + Languages : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall Item( + /*[in]*/ VARIANT index, + /*[out,retval]*/ struct Language * * Language) = 0; + virtual HRESULT __stdcall _NewEnum( + /*[out,retval]*/ IUnknown * * Enumerator) = 0; + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * DTEObject) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct Debugger * * Debugger) = 0; + virtual HRESULT __stdcall get_Count( + /*[out,retval]*/ long * Count) = 0; + }; + + struct __declspec(uuid("b3ccfa68-c145-11d2-8ad1-00c04f79e479")) + Language : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_Name( + /*[out,retval]*/ BSTR * Name) = 0; + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * DTE) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct Debugger * * Debugger) = 0; + virtual HRESULT __stdcall get_Collection( + /*[out,retval]*/ struct Languages * * Languages) = 0; + }; + + struct __declspec(uuid("26f6cc4b-7a48-4e4d-8af5-9e960232e05f")) + _Solution : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall Item( + /*[in]*/ VARIANT index, + /*[out,retval]*/ struct Project * * lppcReturn) = 0; + virtual HRESULT __stdcall _NewEnum( + /*[out,retval]*/ IUnknown * * lppiuReturn) = 0; + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * lppaReturn) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct _DTE * * lppaReturn) = 0; + virtual HRESULT __stdcall get_Count( + /*[out,retval]*/ long * lplReturn) = 0; + virtual HRESULT __stdcall get_FileName( + /*[out,retval]*/ BSTR * lpbstrReturn) = 0; + virtual HRESULT __stdcall SaveAs( + /*[in]*/ BSTR FileName) = 0; + virtual HRESULT __stdcall AddFromTemplate( + /*[in]*/ BSTR FileName, + /*[in]*/ BSTR Destination, + /*[in]*/ BSTR ProjectName, + /*[in]*/ VARIANT_BOOL Exclusive, + /*[out,retval]*/ struct Project * * IppptReturn) = 0; + virtual HRESULT __stdcall AddFromFile( + /*[in]*/ BSTR FileName, + /*[in]*/ VARIANT_BOOL Exclusive, + /*[out,retval]*/ struct Project * * IppptReturn) = 0; + virtual HRESULT __stdcall Open( + /*[in]*/ BSTR FileName) = 0; + virtual HRESULT __stdcall Close( + /*[in]*/ VARIANT_BOOL SaveFirst) = 0; + virtual HRESULT __stdcall get_Properties( + /*[out,retval]*/ struct Properties * * ppObject) = 0; + virtual HRESULT __stdcall get_IsDirty( + /*[out,retval]*/ VARIANT_BOOL * lpfReturn) = 0; + virtual HRESULT __stdcall put_IsDirty( + /*[in]*/ VARIANT_BOOL lpfReturn) = 0; + virtual HRESULT __stdcall Remove( + /*[in]*/ struct Project * proj) = 0; + virtual HRESULT __stdcall get_TemplatePath( + /*[in]*/ BSTR ProjectType, + /*[out,retval]*/ BSTR * lpbstrPath) = 0; + virtual HRESULT __stdcall get_FullName( + /*[out,retval]*/ BSTR * lpbstrReturn) = 0; + virtual HRESULT __stdcall get_Saved( + /*[out,retval]*/ VARIANT_BOOL * lpfReturn) = 0; + virtual HRESULT __stdcall put_Saved( + /*[in]*/ VARIANT_BOOL lpfReturn) = 0; + virtual HRESULT __stdcall get_Globals( + /*[out,retval]*/ struct Globals * * ppGlobals) = 0; + virtual HRESULT __stdcall get_AddIns( + /*[out,retval]*/ struct AddIns * * ppAddIns) = 0; + virtual HRESULT __stdcall get_Extender( + /*[in]*/ BSTR ExtenderName, + /*[out,retval]*/ IDispatch * * Extender) = 0; + virtual HRESULT __stdcall get_ExtenderNames( + /*[out,retval]*/ VARIANT * ExtenderNames) = 0; + virtual HRESULT __stdcall get_ExtenderCATID( + /*[out,retval]*/ BSTR * pRetval) = 0; + virtual HRESULT __stdcall get_IsOpen( + /*[out,retval]*/ VARIANT_BOOL * pVal) = 0; + virtual HRESULT __stdcall get_SolutionBuild( + /*[out,retval]*/ struct SolutionBuild * * ppSolutionBuild) = 0; + virtual HRESULT __stdcall Create( + BSTR Destination, + BSTR Name) = 0; + virtual HRESULT __stdcall get_Projects( + /*[out,retval]*/ struct Projects * * ppProjects) = 0; + virtual HRESULT __stdcall FindProjectItem( + BSTR FileName, + /*[out,retval]*/ struct ProjectItem * * ppProjectItem) = 0; + virtual HRESULT __stdcall ProjectItemsTemplatePath( + BSTR ProjectKind, + /*[out,retval]*/ BSTR * pFullPath) = 0; + }; + + struct __declspec(uuid("a3c1c40c-9218-4d4c-9daa-075f64f6922c")) + SolutionBuild : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * ppDTE) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct _Solution * * ppSolution) = 0; + virtual HRESULT __stdcall get_ActiveConfiguration( + /*[out,retval]*/ struct SolutionConfiguration * * ppSolutionConfiguration) = 0; + virtual HRESULT __stdcall get_BuildDependencies( + /*[out,retval]*/ struct BuildDependencies * * ppBuildDependencies) = 0; + virtual HRESULT __stdcall get_BuildState( + /*[out,retval]*/ enum vsBuildState * pvsBuildState) = 0; + virtual HRESULT __stdcall get_LastBuildInfo( + /*[out,retval]*/ long * pBuiltSuccessfully) = 0; + virtual HRESULT __stdcall put_StartupProjects( + /*[in]*/ VARIANT pProject) = 0; + virtual HRESULT __stdcall get_StartupProjects( + /*[out,retval]*/ VARIANT * pProject) = 0; + virtual HRESULT __stdcall Build( + /*[in]*/ VARIANT_BOOL WaitForBuildToFinish) = 0; + virtual HRESULT __stdcall Debug() = 0; + virtual HRESULT __stdcall Deploy( + /*[in]*/ VARIANT_BOOL WaitForDeployToFinish) = 0; + virtual HRESULT __stdcall Clean( + /*[in]*/ VARIANT_BOOL WaitForCleanToFinish) = 0; + virtual HRESULT __stdcall Run() = 0; + virtual HRESULT __stdcall get_SolutionConfigurations( + /*[out,retval]*/ struct SolutionConfigurations * * ppSolutionConfigurations) = 0; + virtual HRESULT __stdcall BuildProject( + BSTR SolutionConfiguration, + BSTR ProjectUniqueName, + VARIANT_BOOL WaitForBuildToFinish) = 0; + }; + + struct __declspec(uuid("60aaad75-cb8d-4c62-9959-24d6a6a50de7")) + SolutionConfiguration : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * ppDTE) = 0; + virtual HRESULT __stdcall get_Collection( + /*[out,retval]*/ struct SolutionConfigurations * * ppSolutionConfigurations) = 0; + virtual HRESULT __stdcall get_Name( + /*[out,retval]*/ BSTR * pVal) = 0; + virtual HRESULT __stdcall get_SolutionContexts( + /*[out,retval]*/ struct SolutionContexts * * ppOut) = 0; + virtual HRESULT __stdcall Delete() = 0; + virtual HRESULT __stdcall Activate() = 0; + }; + + struct __declspec(uuid("23e78ed7-c9e1-462d-8bc6-366003486ed9")) + SolutionConfigurations : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall _NewEnum( + /*[out,retval]*/ IUnknown * * Enumerator) = 0; + virtual HRESULT __stdcall Item( + /*[in]*/ VARIANT index, + /*[out,retval]*/ struct SolutionConfiguration * * ppOut) = 0; + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * ppDTE) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct SolutionBuild * * ppBuild) = 0; + virtual HRESULT __stdcall Add( + /*[in]*/ BSTR NewName, + /*[in]*/ BSTR ExistingName, + /*[in]*/ VARIANT_BOOL Propagate, + /*[out,retval]*/ struct SolutionConfiguration * * ppSolutionConfiguration) = 0; + virtual HRESULT __stdcall get_Count( + /*[out,retval]*/ long * pCount) = 0; + }; + + struct __declspec(uuid("0685b546-fb84-4917-ab98-98d40f892d61")) + SolutionContexts : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * ppDTE) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct SolutionConfiguration * * ppSolutionConfiguration) = 0; + virtual HRESULT __stdcall _NewEnum( + /*[out,retval]*/ IUnknown * * Enumerator) = 0; + virtual HRESULT __stdcall Item( + /*[in]*/ VARIANT index, + /*[out,retval]*/ struct SolutionContext * * ppOut) = 0; + virtual HRESULT __stdcall get_Count( + /*[out,retval]*/ long * pCount) = 0; + }; + + struct __declspec(uuid("fc6a1a82-9c8a-47bb-a046-6e965df5a99b")) + SolutionContext : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * ppDTE) = 0; + virtual HRESULT __stdcall get_Collection( + /*[out,retval]*/ struct SolutionContexts * * ppSolutionContexts) = 0; + virtual HRESULT __stdcall get_ProjectName( + /*[out,retval]*/ BSTR * pName) = 0; + virtual HRESULT __stdcall get_ConfigurationName( + /*[out,retval]*/ BSTR * pConfigurationName) = 0; + virtual HRESULT __stdcall put_ConfigurationName( + /*[in]*/ BSTR pConfigurationName) = 0; + virtual HRESULT __stdcall get_PlatformName( + /*[out,retval]*/ BSTR * pPlatformName) = 0; + virtual HRESULT __stdcall get_ShouldBuild( + /*[out,retval]*/ VARIANT_BOOL * pPlatformName) = 0; + virtual HRESULT __stdcall put_ShouldBuild( + /*[in]*/ VARIANT_BOOL pPlatformName) = 0; + virtual HRESULT __stdcall get_ShouldDeploy( + /*[out,retval]*/ VARIANT_BOOL * pPlatformName) = 0; + virtual HRESULT __stdcall put_ShouldDeploy( + /*[in]*/ VARIANT_BOOL pPlatformName) = 0; + }; + + struct __declspec(uuid("ead260eb-1e5b-450a-b628-4cfada11b4a1")) + BuildDependencies : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * ppDTE) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct SolutionBuild * * ppSolutionBuild) = 0; + virtual HRESULT __stdcall _NewEnum( + /*[out,retval]*/ IUnknown * * Enumerator) = 0; + virtual HRESULT __stdcall Item( + /*[in]*/ VARIANT index, + /*[out,retval]*/ struct BuildDependency * * ppOut) = 0; + virtual HRESULT __stdcall get_Count( + /*[out,retval]*/ long * pCount) = 0; + }; + + struct __declspec(uuid("9c5ceaac-062f-4434-a2ed-78ab4d6134fe")) + BuildDependency : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * ppDTE) = 0; + virtual HRESULT __stdcall get_Collection( + /*[out,retval]*/ struct BuildDependencies * * ppBuildDependencies) = 0; + virtual HRESULT __stdcall get_Project( + /*[out,retval]*/ struct Project * * ppProject) = 0; + virtual HRESULT __stdcall get_RequiredProjects( + /*[out,retval]*/ VARIANT * pProjects) = 0; + virtual HRESULT __stdcall AddProject( + BSTR ProjectUniqueName) = 0; + virtual HRESULT __stdcall RemoveProject( + BSTR ProjectUniqueName) = 0; + virtual HRESULT __stdcall RemoveAllProjects() = 0; + }; + + struct __declspec(uuid("e6b96cac-b8c7-40ae-b705-5c81878c4a9e")) + Commands : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * lppaReturn) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct _DTE * * lppaReturn) = 0; + virtual HRESULT __stdcall Add( + /*[in]*/ BSTR Guid, + /*[in]*/ long ID, + /*[in]*/ VARIANT * Control) = 0; + virtual HRESULT __stdcall Raise( + /*[in]*/ BSTR Guid, + /*[in]*/ long ID, + /*[in,out]*/ VARIANT * CustomIn, + /*[in,out]*/ VARIANT * CustomOut) = 0; + virtual HRESULT __stdcall CommandInfo( + /*[in]*/ IDispatch * CommandBarControl, + /*[out]*/ BSTR * Guid, + /*[out]*/ long * ID) = 0; + virtual HRESULT __stdcall get_Count( + /*[out,retval]*/ long * lplReturn) = 0; + virtual HRESULT __stdcall Item( + /*[in]*/ VARIANT index, + /*[in]*/ long ID, + /*[out,retval]*/ struct Command * * lppcReturn) = 0; + virtual HRESULT __stdcall _NewEnum( + /*[out,retval]*/ IUnknown * * lppiuReturn) = 0; + virtual HRESULT __stdcall AddNamedCommand( + /*[in]*/ struct AddIn * AddInInstance, + /*[in]*/ BSTR Name, + /*[in]*/ BSTR ButtonText, + /*[in]*/ BSTR Tooltip, + /*[in]*/ VARIANT_BOOL MSOButton, + /*[in]*/ long Bitmap, + /*[in]*/ SAFEARRAY * * ContextUIGUIDs, + /*[in]*/ long vsCommandDisabledFlagsValue, + /*[out,retval]*/ struct Command * * pVal) = 0; + virtual HRESULT __stdcall AddCommandBar( + /*[in]*/ BSTR Name, + /*[in]*/ enum vsCommandBarType Type, + /*[in]*/ IDispatch * CommandBarParent, + /*[in]*/ long Position, + /*[out,retval]*/ IDispatch * * pVal) = 0; + virtual HRESULT __stdcall RemoveCommandBar( + /*[in]*/ IDispatch * CommandBar) = 0; + }; + + struct __declspec(uuid("5fe10fb0-91a1-4e55-baaa-eccae5cceb94")) + Command : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_Name( + /*[out,retval]*/ BSTR * lpbstr) = 0; + virtual HRESULT __stdcall get_Collection( + /*[out,retval]*/ struct Commands * * lppcReturn) = 0; + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * lppaReturn) = 0; + virtual HRESULT __stdcall get_Guid( + /*[out,retval]*/ BSTR * lpbstr) = 0; + virtual HRESULT __stdcall get_ID( + /*[out,retval]*/ long * lReturn) = 0; + virtual HRESULT __stdcall get_IsAvailable( + /*[out,retval]*/ VARIANT_BOOL * pAvail) = 0; + virtual HRESULT __stdcall AddControl( + /*[in]*/ IDispatch * Owner, + /*[in]*/ long Position, + /*[out,retval]*/ IDispatch * * pCommandBarControl) = 0; + virtual HRESULT __stdcall Delete() = 0; + virtual HRESULT __stdcall get_Bindings( + /*[out,retval]*/ VARIANT * pVar) = 0; + virtual HRESULT __stdcall put_Bindings( + VARIANT pVar) = 0; + virtual HRESULT __stdcall get_LocalizedName( + /*[out,retval]*/ BSTR * lpbstr) = 0; + }; + + struct __declspec(uuid("6caa67cf-43ae-4184-aaab-0200ddf6b240")) + SelectedItems : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall Item( + /*[in]*/ VARIANT index, + /*[out,retval]*/ struct SelectedItem * * lplppReturn) = 0; + virtual HRESULT __stdcall _NewEnum( + /*[out,retval]*/ IUnknown * * lppiuReturn) = 0; + virtual HRESULT __stdcall get_Count( + /*[out,retval]*/ long * lplReturn) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct _DTE * * lppaReturn) = 0; + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * lppaReturn) = 0; + virtual HRESULT __stdcall get_MultiSelect( + /*[out,retval]*/ VARIANT_BOOL * pfMultiSelect) = 0; + virtual HRESULT __stdcall get_SelectionContainer( + /*[out,retval]*/ struct SelectionContainer * * lppdispSelContainer) = 0; + }; + + struct __declspec(uuid("049d2cdf-3731-4cb6-a233-be97bce922d3")) + SelectedItem : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_Collection( + /*[out,retval]*/ struct SelectedItems * * lppReturn) = 0; + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * lppReturn) = 0; + virtual HRESULT __stdcall get_Project( + /*[out,retval]*/ struct Project * * lppReturn) = 0; + virtual HRESULT __stdcall get_ProjectItem( + /*[out,retval]*/ struct ProjectItem * * lppReturn) = 0; + virtual HRESULT __stdcall get_Name( + /*[out,retval]*/ BSTR * lpbstrReturn) = 0; + virtual HRESULT __stdcall get_InfoCount( + /*[out,retval]*/ short * lpnCount) = 0; + virtual HRESULT __stdcall get_Info( + /*[in]*/ short index, + /*[out,retval]*/ VARIANT * lpbstrReturn) = 0; + }; + + struct __declspec(uuid("02273422-8dd4-4a9f-8a8b-d70443d510f4")) + SelectionContainer : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall Item( + /*[in]*/ VARIANT index, + /*[out,retval]*/ IDispatch * * lplppReturn) = 0; + virtual HRESULT __stdcall _NewEnum( + /*[out,retval]*/ IUnknown * * lppiuReturn) = 0; + virtual HRESULT __stdcall get_Count( + /*[out,retval]*/ long * lplReturn) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct SelectedItems * * lppReturn) = 0; + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * lppReturn) = 0; + }; + + struct __declspec(uuid("e577442a-98e1-46c5-bd2e-d25807ec81ce")) + WindowConfigurations : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall _NewEnum( + /*[out,retval]*/ IUnknown * * ppEnum) = 0; + virtual HRESULT __stdcall Item( + /*[in]*/ VARIANT index, + /*[out,retval]*/ struct WindowConfiguration * * pWindowConfiguration) = 0; + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * pDTE) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct _DTE * * pParent) = 0; + virtual HRESULT __stdcall get_Count( + /*[out,retval]*/ long * pCount) = 0; + virtual HRESULT __stdcall Add( + /*[in]*/ BSTR Name, + /*[out,retval]*/ struct WindowConfiguration * * pWindowConfiguration) = 0; + virtual HRESULT __stdcall get_ActiveConfigurationName( + /*[out,retval]*/ BSTR * pbstrName) = 0; + }; + + struct __declspec(uuid("41d02413-8a67-4c28-a980-ad7539ed415d")) + WindowConfiguration : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_Name( + /*[out,retval]*/ BSTR * pName) = 0; + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * pDTE) = 0; + virtual HRESULT __stdcall get_Collection( + /*[out,retval]*/ struct WindowConfigurations * * pWindowConfigurations) = 0; + virtual HRESULT __stdcall Apply( + /*[in]*/ VARIANT_BOOL FromCustomViews) = 0; + virtual HRESULT __stdcall Delete() = 0; + virtual HRESULT __stdcall Update() = 0; + }; + + struct __declspec(uuid("56fcd5af-7f17-4c5c-aa8d-ae2bb2ddbf38")) + ToolBox : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * pDTE) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct Window * * pParent) = 0; + virtual HRESULT __stdcall get_ActiveTab( + /*[out,retval]*/ struct ToolBoxTab * * pToolBoxTab) = 0; + virtual HRESULT __stdcall get_ToolBoxTabs( + /*[out,retval]*/ struct ToolBoxTabs * * pToolBoxTabs) = 0; + }; + + struct __declspec(uuid("ce2def9e-3387-4bf2-967b-a1f7f70df325")) + ToolBoxTab : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_Name( + /*[out,retval]*/ BSTR * pName) = 0; + virtual HRESULT __stdcall put_Name( + /*[in]*/ BSTR pName) = 0; + virtual HRESULT __stdcall get_Collection( + /*[out,retval]*/ struct ToolBoxTabs * * pToolBoxTabs) = 0; + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * pDTE) = 0; + virtual HRESULT __stdcall Activate() = 0; + virtual HRESULT __stdcall Delete() = 0; + virtual HRESULT __stdcall get_ToolBoxItems( + /*[out,retval]*/ struct ToolBoxItems * * pToolBoxItems) = 0; + virtual HRESULT __stdcall get_ListView( + /*[out,retval]*/ VARIANT_BOOL * pListView) = 0; + virtual HRESULT __stdcall put_ListView( + /*[in]*/ VARIANT_BOOL pListView) = 0; + }; + + struct __declspec(uuid("cf177b52-4f2f-42a0-8da3-ce78679a0d2d")) + ToolBoxTabs : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall _NewEnum( + /*[out,retval]*/ IUnknown * * lppiuReturn) = 0; + virtual HRESULT __stdcall Item( + VARIANT index, + /*[out,retval]*/ struct ToolBoxTab * * pItem) = 0; + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * pDTE) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct ToolBox * * pParent) = 0; + virtual HRESULT __stdcall get_Count( + /*[out,retval]*/ long * pCount) = 0; + virtual HRESULT __stdcall Add( + /*[in]*/ BSTR Name, + /*[out,retval]*/ struct ToolBoxTab * * pToolBoxTabs) = 0; + }; + + struct __declspec(uuid("395c7dfb-f158-431c-8f43-dda83b4ef54e")) + ToolBoxItems : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall _NewEnum( + /*[out,retval]*/ IUnknown * * lppiuReturn) = 0; + virtual HRESULT __stdcall Item( + VARIANT index, + /*[out,retval]*/ struct ToolBoxItem * * pItem) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct ToolBoxTab * * pParent) = 0; + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * pDTE) = 0; + virtual HRESULT __stdcall get_Count( + /*[out,retval]*/ long * pCount) = 0; + virtual HRESULT __stdcall Add( + /*[in]*/ BSTR Name, + /*[in]*/ VARIANT Data, + /*[in]*/ enum vsToolBoxItemFormat Format, + /*[out,retval]*/ struct ToolBoxItem * * pToolBoxItem) = 0; + virtual HRESULT __stdcall get_SelectedItem( + /*[out,retval]*/ struct ToolBoxItem * * pToolBoxItem) = 0; + }; + + struct __declspec(uuid("46538d1b-4d81-4002-8bb4-dbdb65babb23")) + ToolBoxItem : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_Name( + /*[out,retval]*/ BSTR * Name) = 0; + virtual HRESULT __stdcall put_Name( + /*[in]*/ BSTR Name) = 0; + virtual HRESULT __stdcall get_Collection( + /*[out,retval]*/ struct ToolBoxItems * * pToolBoxItems) = 0; + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * pDTE) = 0; + virtual HRESULT __stdcall Delete() = 0; + virtual HRESULT __stdcall Select() = 0; + }; + + struct __declspec(uuid("fbd0d024-09cd-4d9f-9e2b-cacd628426a5")) + UIHierarchyItem : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * ppDTE) = 0; + virtual HRESULT __stdcall get_Collection( + /*[out,retval]*/ struct UIHierarchyItems * * ppUIHierarchyItems) = 0; + virtual HRESULT __stdcall get_Name( + /*[out,retval]*/ BSTR * pbstrName) = 0; + virtual HRESULT __stdcall get_UIHierarchyItems( + /*[out,retval]*/ struct UIHierarchyItems * * ppUIHierarchyItems) = 0; + virtual HRESULT __stdcall get_Object( + /*[out,retval]*/ IDispatch * * ppDispatch) = 0; + virtual HRESULT __stdcall Select( + /*[in]*/ enum vsUISelectionType How) = 0; + virtual HRESULT __stdcall get_IsSelected( + /*[out,retval]*/ VARIANT_BOOL * pfSelected) = 0; + }; + + struct __declspec(uuid("db8406b0-a916-449c-a277-bb04028f4394")) + UIHierarchyItems : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * ppDTE) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ IDispatch * * ppDispatch) = 0; + virtual HRESULT __stdcall get_Count( + /*[out,retval]*/ long * pCount) = 0; + virtual HRESULT __stdcall Item( + /*[in]*/ VARIANT index, + /*[out,retval]*/ struct UIHierarchyItem * * ppUIHierarchyItem) = 0; + virtual HRESULT __stdcall get_Expanded( + /*[out,retval]*/ VARIANT_BOOL * pfExpanded) = 0; + virtual HRESULT __stdcall put_Expanded( + /*[in]*/ VARIANT_BOOL pfExpanded) = 0; + virtual HRESULT __stdcall _NewEnum( + /*[out,retval]*/ IUnknown * * ppUnknown) = 0; + }; + + struct __declspec(uuid("72a2a2ef-c209-408c-a377-76871774adb7")) + UIHierarchy : IDispatch + { + // + // Raw methods provided by interface + // + + virtual HRESULT __stdcall get_DTE( + /*[out,retval]*/ struct _DTE * * ppDTE) = 0; + virtual HRESULT __stdcall get_Parent( + /*[out,retval]*/ struct Window * * ppWin) = 0; + virtual HRESULT __stdcall get_UIHierarchyItems( + /*[out,retval]*/ struct UIHierarchyItems * * ppUIHierarchyItems) = 0; + virtual HRESULT __stdcall get_SelectedItems( + /*[out,retval]*/ VARIANT * pvarSel) = 0; + virtual HRESULT __stdcall GetItem( + /*[in]*/ BSTR Names, + /*[out,retval]*/ struct UIHierarchyItem * * ppUIHierarchyItem) = 0; + virtual HRESULT __stdcall SelectUp( + /*[in]*/ enum vsUISelectionType How, + /*[in]*/ long Count) = 0; + virtual HRESULT __stdcall SelectDown( + /*[in]*/ enum vsUISelectionType How, + /*[in]*/ long Count) = 0; + virtual HRESULT __stdcall DoDefaultAction() = 0; + }; + + // + // Named GUID constants initializations + // + + extern "C" const GUID __declspec(selectany) LIBID_EnvDTE = + { 0x80cc9f66,0xe7d8,0x4ddd,{0x85,0xb6,0xd9,0xe6,0xcd,0x0e,0x93,0xe2} }; + extern "C" const GUID __declspec(selectany) CLSID_DTE = + { 0x3c9cfe1e,0x389f,0x4118,{0x9f,0xad,0x36,0x53,0x85,0x19,0x03,0x29} }; + extern "C" const GUID __declspec(selectany) IID_Globals = + { 0xe68a3e0e,0xb435,0x4dde,{0x86,0xb7,0xf5,0xad,0xef,0xc1,0x9d,0xf2} }; + extern "C" const GUID __declspec(selectany) CLSID_CommandEvents = + { 0x1ded92b5,0x9a46,0x4b29,{0x93,0xef,0xb5,0xe0,0x70,0x16,0x65,0x9e} }; + extern "C" const GUID __declspec(selectany) IID__CommandEvents = + { 0xa79fc678,0x0d0a,0x496a,{0xb9,0xdc,0x0d,0x5b,0x9e,0x1c,0xa9,0xfc} }; + extern "C" const GUID __declspec(selectany) DIID__dispCommandEvents = + { 0xff2d5c12,0xfeea,0x11d0,{0xbb,0xc8,0x00,0xa0,0xc9,0x0f,0x27,0x44} }; + extern "C" const GUID __declspec(selectany) CLSID_SelectionEvents = + { 0xaf37511e,0x9e9d,0x4234,{0xa5,0xa1,0x75,0x84,0xd2,0x90,0xe0,0x61} }; + extern "C" const GUID __declspec(selectany) IID__SelectionEvents = + { 0xeb6783db,0x1819,0x496d,{0x84,0xa4,0x3c,0xff,0x88,0x30,0x10,0xf6} }; + extern "C" const GUID __declspec(selectany) DIID__dispSelectionEvents = + { 0xdeeb28b3,0x23e6,0x11d1,{0xae,0x5c,0x00,0xa0,0xc9,0x0f,0x26,0xf4} }; + extern "C" const GUID __declspec(selectany) CLSID_SolutionEvents = + { 0x88ac98c7,0xb38c,0x404b,{0xbd,0x86,0xd2,0xa4,0xf2,0xe8,0x9d,0xca} }; + extern "C" const GUID __declspec(selectany) IID__SolutionEvents = + { 0xbf8bbf37,0x5415,0x46a9,{0x94,0x0d,0x59,0x4c,0xad,0x9d,0xec,0x26} }; + extern "C" const GUID __declspec(selectany) DIID__dispSolutionEvents = + { 0xfbcff1c2,0x261c,0x11d1,{0xae,0x5e,0x00,0xa0,0xc9,0x0f,0x26,0xf4} }; + extern "C" const GUID __declspec(selectany) CLSID_BuildEvents = + { 0xd83d60e3,0x229f,0x4660,{0x8d,0xd0,0x28,0xb6,0x29,0xee,0xdc,0xda} }; + extern "C" const GUID __declspec(selectany) IID__BuildEvents = + { 0x794a2ba5,0xffa6,0x4fc5,{0xbf,0x13,0x95,0x7b,0x2c,0x22,0xed,0xd7} }; + extern "C" const GUID __declspec(selectany) DIID__dispBuildEvents = + { 0x1926364e,0x6b90,0x46cb,{0xa4,0x4d,0x8a,0x80,0xfb,0x11,0xac,0xd9} }; + extern "C" const GUID __declspec(selectany) CLSID_WindowEvents = + { 0x2e260fd4,0xc130,0x4e6d,{0x8e,0xbc,0x4a,0x3b,0xfd,0x18,0x81,0x81} }; + extern "C" const GUID __declspec(selectany) IID__WindowEvents = + { 0x0d3a23a8,0x67bb,0x11d2,{0x97,0xc1,0x00,0xc0,0x4f,0xb6,0xc6,0xff} }; + extern "C" const GUID __declspec(selectany) DIID__dispWindowEvents = + { 0x0d3a23a9,0x67bb,0x11d2,{0x97,0xc1,0x00,0xc0,0x4f,0xb6,0xc6,0xff} }; + extern "C" const GUID __declspec(selectany) CLSID_OutputWindowEvents = + { 0x3760037f,0xb012,0x44f8,{0x9c,0x23,0x36,0x09,0xd7,0xa1,0x6d,0xef} }; + extern "C" const GUID __declspec(selectany) IID__OutputWindowEvents = + { 0x0a3546a8,0x6840,0x11d2,{0x97,0xc1,0x00,0xc0,0x4f,0xb6,0xc6,0xff} }; + extern "C" const GUID __declspec(selectany) DIID__dispOutputWindowEvents = + { 0x0d3a23af,0x67bb,0x11d2,{0x97,0xc1,0x00,0xc0,0x4f,0xb6,0xc6,0xff} }; + extern "C" const GUID __declspec(selectany) CLSID_FindEvents = + { 0x811322bc,0x042d,0x4828,{0xbf,0xf2,0x64,0x0e,0xf8,0xb7,0x20,0x9f} }; + extern "C" const GUID __declspec(selectany) IID__FindEvents = + { 0xc5331acd,0xc5d5,0x11d2,{0x85,0x98,0x00,0x60,0x97,0xc6,0x8e,0x81} }; + extern "C" const GUID __declspec(selectany) DIID__dispFindEvents = + { 0xc5331ace,0xc5d5,0x11d2,{0x85,0x98,0x00,0x60,0x97,0xc6,0x8e,0x81} }; + extern "C" const GUID __declspec(selectany) CLSID_TaskListEvents = + { 0x29617acd,0x7859,0x4328,{0xbe,0x09,0x29,0x8f,0x91,0xf4,0x81,0x96} }; + extern "C" const GUID __declspec(selectany) IID__TaskListEvents = + { 0x1125c422,0x49bd,0x11d2,{0x88,0x23,0x00,0xc0,0x4f,0xb6,0xc6,0xff} }; + extern "C" const GUID __declspec(selectany) DIID__dispTaskListEvents = + { 0x1125c423,0x49bd,0x11d2,{0x88,0x23,0x00,0xc0,0x4f,0xb6,0xc6,0xff} }; + extern "C" const GUID __declspec(selectany) CLSID_DTEEvents = + { 0xc6304bab,0x6765,0x4c63,{0x90,0x17,0x49,0x40,0xae,0xb6,0xf2,0x07} }; + extern "C" const GUID __declspec(selectany) IID__DTEEvents = + { 0xfa1bb6d7,0xca83,0x11d2,{0xaa,0xb2,0x00,0xc0,0x4f,0x68,0x8d,0xde} }; + extern "C" const GUID __declspec(selectany) DIID__dispDTEEvents = + { 0xb50c9708,0xc909,0x4b87,{0xa0,0x3d,0xaf,0x6c,0xc4,0xbf,0xb4,0x22} }; + extern "C" const GUID __declspec(selectany) CLSID_DocumentEvents = + { 0xdc5437f7,0xf114,0x11d2,{0xaa,0xcf,0x00,0xc0,0x4f,0x68,0x8d,0xde} }; + extern "C" const GUID __declspec(selectany) IID__DocumentEvents = + { 0xdc5437f5,0xf114,0x11d2,{0xaa,0xcf,0x00,0xc0,0x4f,0x68,0x8d,0xde} }; + extern "C" const GUID __declspec(selectany) DIID__dispDocumentEvents = + { 0xdc5437f6,0xf114,0x11d2,{0xaa,0xcf,0x00,0xc0,0x4f,0x68,0x8d,0xde} }; + extern "C" const GUID __declspec(selectany) CLSID_ProjectItemsEvents = + { 0xde6c1098,0x93ca,0x4f49,{0xbe,0xf0,0x26,0x2a,0x13,0xca,0x11,0x76} }; + extern "C" const GUID __declspec(selectany) IID__ProjectItemsEvents = + { 0x22800963,0x2811,0x410d,{0xbf,0x87,0xa7,0x80,0x8e,0xac,0x97,0x7d} }; + extern "C" const GUID __declspec(selectany) DIID__dispProjectItemsEvents = + { 0x6962753f,0xefd5,0x41c5,{0xb0,0x83,0xd7,0x06,0x87,0x16,0x6a,0xeb} }; + extern "C" const GUID __declspec(selectany) CLSID_DebuggerEvents = + { 0x0c763210,0x0fbb,0x11d3,{0xb8,0x80,0x00,0xc0,0x4f,0x79,0xe4,0x79} }; + extern "C" const GUID __declspec(selectany) IID__DebuggerEvents = + { 0xd4eae958,0x0fba,0x11d3,{0xb8,0x80,0x00,0xc0,0x4f,0x79,0xe4,0x79} }; + extern "C" const GUID __declspec(selectany) DIID__dispDebuggerEvents = + { 0x46209330,0x0fba,0x11d3,{0xb8,0x80,0x00,0xc0,0x4f,0x79,0xe4,0x79} }; + extern "C" const GUID __declspec(selectany) CLSID_TextEditorEvents = + { 0xadf22c37,0x0069,0x4adf,{0xb1,0x2d,0xd8,0xd4,0x7c,0x38,0xfe,0x79} }; + extern "C" const GUID __declspec(selectany) IID__TextEditorEvents = + { 0x23b7a868,0x6c89,0x436a,{0x94,0xfa,0x25,0xd7,0x55,0x45,0x6a,0x77} }; + extern "C" const GUID __declspec(selectany) DIID__dispTextEditorEvents = + { 0x2699dd44,0xc507,0x4da3,{0xaa,0x34,0x31,0x4a,0x6c,0x21,0xdf,0xe2} }; + extern "C" const GUID __declspec(selectany) CLSID_Solution = + { 0xb35caa8c,0x77de,0x4ab3,{0x8e,0x5a,0xf0,0x38,0xe3,0xfc,0x60,0x56} }; + extern "C" const GUID __declspec(selectany) IID_StatusBar = + { 0xc34301a1,0x3ef1,0x41d8,{0x93,0x2a,0xfe,0xa4,0xa8,0xa8,0xce,0x0c} }; + extern "C" const GUID __declspec(selectany) IID_IExtenderSite = + { 0xe57c510b,0x968b,0x4a3c,{0xa4,0x67,0xee,0x40,0x13,0x15,0x7d,0xc9} }; + extern "C" const GUID __declspec(selectany) IID_IExtenderProvider = + { 0x4db06329,0x23f4,0x443b,{0x9a,0xbd,0x9c,0xf6,0x11,0xe8,0xae,0x07} }; + extern "C" const GUID __declspec(selectany) IID_IExtenderProviderUnk = + { 0xf69b64a3,0x9017,0x4e48,{0x97,0x84,0xe1,0x52,0xb5,0x1a,0xa7,0x22} }; + extern "C" const GUID __declspec(selectany) IID_ObjectExtenders = + { 0x8d0aa9cc,0x8465,0x42f3,{0xad,0x6e,0xdf,0xde,0x28,0xcc,0xc7,0x5d} }; + extern "C" const GUID __declspec(selectany) IID_Find = + { 0x40d4b9b6,0x739b,0x4965,{0x8d,0x65,0x69,0x2a,0xec,0x69,0x22,0x66} }; + extern "C" const GUID __declspec(selectany) IID_UndoContext = + { 0xd8dec44d,0xcaf2,0x4b39,{0xa5,0x39,0xb9,0x1a,0xe9,0x21,0xba,0x92} }; + extern "C" const GUID __declspec(selectany) IID_Macros = + { 0xf9f99155,0x6d4d,0x49b1,{0xad,0x63,0xc7,0x8c,0x3e,0x8a,0x59,0x16} }; + extern "C" const GUID __declspec(selectany) IID_SourceControl = + { 0xf1ddc2c2,0xdf76,0x4ebb,{0x9d,0xe8,0x48,0xad,0x25,0x57,0x06,0x2c} }; + extern "C" const GUID __declspec(selectany) IID_ISupportVSProperties = + { 0x6659ed14,0x2ab6,0x47f3,{0xa8,0x90,0x00,0xc8,0xab,0xa4,0x3b,0x84} }; + extern "C" const GUID __declspec(selectany) IID_IExtensibleObjectSite = + { 0xeb5be8a7,0xe593,0x4de6,{0xa9,0x23,0xc2,0xaf,0xec,0xb9,0x63,0x36} }; + extern "C" const GUID __declspec(selectany) IID_IVsProfferCommands = + { 0x8cc0cde1,0xc16a,0x4749,{0x99,0xaf,0x6f,0x75,0x23,0xc3,0x4a,0x57} }; + extern "C" const GUID __declspec(selectany) IID_IFilterProperties = + { 0xaade1f59,0x6ace,0x43d1,{0x8f,0xca,0x42,0xaf,0x3a,0x5c,0x4f,0x3c} }; + extern "C" const GUID __declspec(selectany) IID_TextEditor = + { 0x9ff3ddca,0x1795,0x4191,{0xa5,0xb1,0x02,0xd1,0xae,0x35,0xd0,0x74} }; + extern "C" const GUID __declspec(selectany) IID__DebuggerEventsRoot = + { 0xd4bb39fb,0x0f0e,0x11d3,{0xb8,0x80,0x00,0xc0,0x4f,0x79,0xe4,0x79} }; + extern "C" const GUID __declspec(selectany) IID_IDTWizard = + { 0xe914bbe1,0x03a4,0x11d1,{0xbb,0xcd,0x00,0xa0,0xc9,0x0f,0x27,0x44} }; + extern "C" const GUID __declspec(selectany) IID_IVsGlobalsCallback = + { 0xe2cc506a,0x588b,0x4f65,{0xa1,0xf0,0x22,0x44,0xc0,0x60,0xab,0xcb} }; + extern "C" const GUID __declspec(selectany) IID_IVsGlobals = + { 0x192ac688,0xe7c6,0x4f9d,{0x81,0x80,0x4b,0x37,0xef,0xbf,0x6f,0x3a} }; + extern "C" const GUID __declspec(selectany) IID_IDTCommandTarget = + { 0x7ef39a3e,0x590d,0x4879,{0x88,0xd4,0xc9,0xbe,0x5b,0xcf,0xd9,0x2e} }; + extern "C" const GUID __declspec(selectany) IID__ProjectsEvents = + { 0x85451f83,0xb5ca,0x437f,{0xa6,0x19,0x0c,0xb7,0x05,0x70,0x74,0x20} }; + extern "C" const GUID __declspec(selectany) DIID__dispProjectsEvents = + { 0x7f508d55,0x627f,0x4d7f,{0xbe,0x0b,0x9e,0x3d,0x82,0x9f,0xf0,0xed} }; + extern "C" const GUID __declspec(selectany) CLSID_ProjectsEvents = + { 0x536a4be3,0xa376,0x408e,{0x95,0x4c,0x47,0x1c,0x77,0x9e,0x21,0x6f} }; + extern "C" const GUID __declspec(selectany) IID__MiscSlnFilesEventsRoot = + { 0x7658b944,0xf37b,0x11d2,{0xaa,0xcf,0x00,0xc0,0x4f,0x68,0x8d,0xde} }; + extern "C" const GUID __declspec(selectany) IID__CommandBarControlEvents = + { 0x9e66fe98,0xa1c6,0x421d,{0x8c,0x0c,0x6d,0xa4,0xe6,0x52,0xe7,0x70} }; + extern "C" const GUID __declspec(selectany) DIID__dispCommandBarControlEvents = + { 0x987fb893,0xf96d,0x11d0,{0xbb,0xbb,0x00,0xa0,0xc9,0x0f,0x27,0x44} }; + extern "C" const GUID __declspec(selectany) CLSID_CommandBarEvents = + { 0xbfd4b2b2,0x9eec,0x4db8,{0xab,0xa0,0xac,0x31,0x6f,0x4c,0x73,0x28} }; + extern "C" const GUID __declspec(selectany) IID__OutputWindowEventsRoot = + { 0xaa6f4085,0x33b6,0x4629,{0xb9,0xea,0x69,0x21,0x01,0x00,0x7c,0xc2} }; + extern "C" const GUID __declspec(selectany) IID__TaskListEventsRoot = + { 0x6bc8c372,0xc6f0,0x4be6,{0xb2,0x55,0x82,0x7a,0xc1,0x90,0xbf,0x71} }; + extern "C" const GUID __declspec(selectany) IID_IDTToolsOptionsPage = + { 0xbdcaf240,0x2692,0x4713,{0x90,0x2a,0xb1,0x10,0xb1,0xd0,0xf1,0x00} }; + extern "C" const GUID __declspec(selectany) IID__EnvironmentWebBrowser = + { 0xa3286b03,0x5ac6,0x44f0,{0x8c,0xc3,0xeb,0xed,0x7f,0x11,0x24,0xe5} }; + extern "C" const GUID __declspec(selectany) IID__EnvironmentHelp = + { 0xaebded64,0xa206,0x11d3,{0xb8,0xb5,0x00,0xc0,0x4f,0x79,0xf8,0x02} }; + extern "C" const GUID __declspec(selectany) IID_ColorableItems = + { 0xe5d17051,0xd6e5,0x4da7,{0x8b,0x3a,0xca,0x88,0x86,0x17,0xa5,0xe7} }; + extern "C" const GUID __declspec(selectany) IID_FontsAndColorsItems = + { 0xf25ae7e6,0x1460,0x4ba4,{0x8e,0x5e,0xbb,0xbe,0x74,0x6d,0xe3,0x53} }; + extern "C" const GUID __declspec(selectany) IID__FontsAndColors = + { 0x256068f6,0x1add,0x4f7b,{0xba,0x76,0x57,0x13,0x14,0xc4,0x13,0xad} }; + extern "C" const GUID __declspec(selectany) IID__EnvironmentGeneral = + { 0x48e61d9c,0x8c8d,0x42d3,{0x91,0x4b,0x46,0xd7,0x0c,0x8b,0x7a,0x40} }; + extern "C" const GUID __declspec(selectany) IID__EnvironmentFontsAndColors = + { 0xf809cab6,0x2c9f,0x41f2,{0xa5,0xaf,0xe2,0x6f,0xb8,0x0e,0x62,0xad} }; + extern "C" const GUID __declspec(selectany) IID__EnvironmentProjectsAndSolution = + { 0x478f06d4,0x5d57,0x473f,{0x9b,0x74,0x5f,0x8e,0x88,0xef,0xa5,0xe7} }; + extern "C" const GUID __declspec(selectany) IID__EnvironmentDocuments = + { 0x76ed1c48,0xed86,0x4e9e,{0xac,0xf8,0xa4,0x0e,0x76,0x5d,0xaf,0x25} }; + extern "C" const GUID __declspec(selectany) IID__EnvironmentTaskList = + { 0x4bc18a5b,0xdbb6,0x4af5,{0xa4,0x43,0x2e,0x3f,0x19,0x36,0x53,0x04} }; + extern "C" const GUID __declspec(selectany) IID__EnvironmentKeyboard = + { 0x9c722678,0x490d,0x408f,{0x98,0xae,0xb6,0xb9,0xa6,0x8a,0xa4,0x5d} }; + extern "C" const GUID __declspec(selectany) IID_IExtensibleObject = + { 0x86c31347,0x5b52,0x4715,{0xb4,0x54,0xa6,0xe5,0xfc,0xab,0x97,0x5d} }; + extern "C" const GUID __declspec(selectany) IID_IVsTextEditGeneral = + { 0x2e1bfd1c,0x5b26,0x4aca,{0xb9,0x7b,0xed,0x9d,0x26,0x1b,0xa3,0xe7} }; + extern "C" const GUID __declspec(selectany) IID_IVsTextEditPerLanguage = + { 0x5943bd7e,0xd722,0x42db,{0xa2,0x51,0xfe,0x2a,0xdd,0x87,0x11,0xea} }; + extern "C" const GUID __declspec(selectany) IID_IVsTextEditFonts = + { 0xf39ab913,0xe6c9,0x4546,{0xa2,0x65,0x1e,0x43,0xf8,0xde,0x92,0x4c} }; + extern "C" const GUID __declspec(selectany) IID__DTE = + { 0x04a72314,0x32e9,0x48e2,{0x9b,0x87,0xa6,0x36,0x03,0x45,0x4f,0x3e} }; + extern "C" const GUID __declspec(selectany) IID_Windows = + { 0x2294311a,0xb7bc,0x4789,{0xb3,0x65,0x1c,0x15,0xff,0x2c,0xd1,0x7c} }; + extern "C" const GUID __declspec(selectany) IID_Window = + { 0x0beab46b,0x4c07,0x4f94,{0xa8,0xd7,0x16,0x26,0x02,0x0e,0x4e,0x53} }; + extern "C" const GUID __declspec(selectany) IID_LinkedWindows = + { 0xf00ef34a,0xa654,0x4c1b,{0x89,0x7a,0x58,0x5d,0x5b,0xcb,0xb3,0x5a} }; + extern "C" const GUID __declspec(selectany) IID_TextBuffer = + { 0xf47dc7e7,0x84b6,0x474f,{0xbb,0x91,0x63,0x16,0x40,0xaa,0x05,0x60} }; + extern "C" const GUID __declspec(selectany) IID__WindowEventsRoot = + { 0x17d12026,0xba99,0x403e,{0xa3,0x59,0x71,0xfd,0x1e,0x5a,0x72,0xcd} }; + extern "C" const GUID __declspec(selectany) IID_HTMLWindow = + { 0xf6576203,0xfbce,0x477e,{0xa6,0x6b,0xed,0xa2,0x37,0xbb,0x68,0xa7} }; + extern "C" const GUID __declspec(selectany) IID_ProjectItem = + { 0x0b48100a,0x473e,0x433c,{0xab,0x8f,0x66,0xb9,0x73,0x9a,0xb6,0x20} }; + extern "C" const GUID __declspec(selectany) IID_ItemOperations = + { 0xd5dbe57b,0xc074,0x4e95,{0xb0,0x15,0xab,0xee,0xaa,0x39,0x16,0x93} }; + extern "C" const GUID __declspec(selectany) IID_ProjectItems = + { 0x8e2f1269,0x185e,0x43c7,{0x88,0x99,0x95,0x0a,0xd2,0x76,0x9c,0xcf} }; + extern "C" const GUID __declspec(selectany) IID_Project = + { 0x866311e6,0xc887,0x4143,{0x98,0x33,0x64,0x5f,0x5b,0x93,0xf6,0xf1} }; + extern "C" const GUID __declspec(selectany) IID_Projects = + { 0xe3ec0add,0x31b3,0x461f,{0x83,0x03,0x8a,0x5e,0x69,0x31,0x25,0x7a} }; + extern "C" const GUID __declspec(selectany) IID_Properties = + { 0x4cc8ccf5,0xa926,0x4646,{0xb1,0x7f,0xb4,0x94,0x0c,0xae,0xd4,0x72} }; + extern "C" const GUID __declspec(selectany) IID_Property = + { 0x7b988e06,0x2581,0x485e,{0x93,0x22,0x04,0x88,0x1e,0x06,0x00,0xd0} }; + extern "C" const GUID __declspec(selectany) IID_ConfigurationManager = + { 0x9043fda1,0x345b,0x4364,{0x90,0x0f,0xbc,0x85,0x98,0xeb,0x8e,0x4f} }; + extern "C" const GUID __declspec(selectany) IID_Configuration = + { 0x90813589,0xfe21,0x4aa4,{0xa2,0xe5,0x05,0x3f,0xd2,0x74,0xe9,0x80} }; + extern "C" const GUID __declspec(selectany) IID_Configurations = + { 0xb6b4c8d6,0x4d27,0x43b9,{0xb4,0x5c,0x52,0xbd,0x16,0xb6,0xba,0x38} }; + extern "C" const GUID __declspec(selectany) IID_OutputGroups = + { 0xf9fa748e,0xe302,0x44cf,{0x89,0x1b,0xe2,0x63,0x18,0x9d,0x58,0x5e} }; + extern "C" const GUID __declspec(selectany) IID_OutputGroup = + { 0xa3a80783,0x875f,0x435b,{0x96,0x39,0xe5,0xce,0x88,0x8d,0xf7,0x37} }; + extern "C" const GUID __declspec(selectany) IID_CodeModel = + { 0x0cfbc2b4,0x0d4e,0x11d3,{0x89,0x97,0x00,0xc0,0x4f,0x68,0x8d,0xde} }; + extern "C" const GUID __declspec(selectany) IID_CodeElements = + { 0x0cfbc2b5,0x0d4e,0x11d3,{0x89,0x97,0x00,0xc0,0x4f,0x68,0x8d,0xde} }; + extern "C" const GUID __declspec(selectany) IID_CodeElement = + { 0x0cfbc2b6,0x0d4e,0x11d3,{0x89,0x97,0x00,0xc0,0x4f,0x68,0x8d,0xde} }; + extern "C" const GUID __declspec(selectany) IID_TextPoint = + { 0x7f59e94e,0x4939,0x40d2,{0x9f,0x7f,0xb7,0x65,0x1c,0x25,0x90,0x5d} }; + extern "C" const GUID __declspec(selectany) IID_VirtualPoint = + { 0x42320454,0x626c,0x4dd0,{0x9e,0xcb,0x35,0x7c,0x4f,0x19,0x66,0xd8} }; + extern "C" const GUID __declspec(selectany) IID_CodeAttribute = + { 0x0cfbc2be,0x0d4e,0x11d3,{0x89,0x97,0x00,0xc0,0x4f,0x68,0x8d,0xde} }; + extern "C" const GUID __declspec(selectany) IID_TextDocument = + { 0xcb218890,0x1382,0x472b,{0x91,0x18,0x78,0x27,0x00,0xc8,0x81,0x15} }; + extern "C" const GUID __declspec(selectany) IID_CommandWindow = + { 0x509b9955,0x7303,0x48c9,{0x90,0xd4,0xe1,0x65,0xb9,0x74,0xe6,0xba} }; + extern "C" const GUID __declspec(selectany) IID__TextEditorEventsRoot = + { 0xb3c38885,0xb288,0x44a8,{0xb2,0x90,0x34,0xfe,0x63,0xbf,0x3c,0x76} }; + extern "C" const GUID __declspec(selectany) IID_Document = + { 0x63eb5c39,0xca8f,0x498e,{0x9a,0x66,0x6d,0xd4,0xa2,0x7a,0xc9,0x5b} }; + extern "C" const GUID __declspec(selectany) IID_Documents = + { 0x9e2cf3ea,0x140f,0x413e,{0xbd,0x4b,0x7d,0x46,0x74,0x0c,0xd2,0xf4} }; + extern "C" const GUID __declspec(selectany) IID_Events = + { 0x134170f8,0x93b1,0x42dd,{0x9f,0x89,0xa2,0xac,0x70,0x10,0xba,0x07} }; + extern "C" const GUID __declspec(selectany) IID_IVsExtensibility = + { 0x3c536122,0x57b1,0x46de,{0xab,0x34,0xac,0xc5,0x24,0x14,0x00,0x93} }; + extern "C" const GUID __declspec(selectany) IID__DocumentEventsRoot = + { 0xdc5437f4,0xf114,0x11d2,{0xaa,0xcf,0x00,0xc0,0x4f,0x68,0x8d,0xde} }; + extern "C" const GUID __declspec(selectany) IID_TextSelection = + { 0x1fa0e135,0x399a,0x4d2c,{0xa4,0xfe,0xd2,0x1e,0x24,0x80,0xf9,0x21} }; + extern "C" const GUID __declspec(selectany) IID_TextRanges = + { 0xb6422e9c,0x9efd,0x4f87,{0xbd,0xdc,0xc7,0xfd,0x8f,0x2f,0xd3,0x03} }; + extern "C" const GUID __declspec(selectany) IID_EditPoint = + { 0xc1ffe800,0x028b,0x4475,{0xa9,0x07,0x14,0xf5,0x1f,0x19,0xbb,0x7d} }; + extern "C" const GUID __declspec(selectany) IID_TextRange = + { 0x72767524,0xe3b3,0x43d0,{0xbb,0x46,0xbb,0xe1,0xd5,0x56,0xa9,0xff} }; + extern "C" const GUID __declspec(selectany) IID_TextPane = + { 0x0a3bf283,0x05f8,0x4669,{0x9b,0xcb,0xa8,0x4b,0x64,0x23,0x34,0x9a} }; + extern "C" const GUID __declspec(selectany) IID_TextPanes = + { 0xd9013d31,0x3652,0x46b2,{0xa2,0x5a,0x29,0xa8,0x81,0xb9,0xf8,0x6b} }; + extern "C" const GUID __declspec(selectany) IID_TextWindow = + { 0x2fc54dc9,0x922b,0x44eb,{0x8c,0xc0,0xba,0x18,0x25,0x84,0xdc,0x4b} }; + extern "C" const GUID __declspec(selectany) IID_CodeType = + { 0x0cfbc2b7,0x0d4e,0x11d3,{0x89,0x97,0x00,0xc0,0x4f,0x68,0x8d,0xde} }; + extern "C" const GUID __declspec(selectany) IID_CodeTypeRef = + { 0x0cfbc2bc,0x0d4e,0x11d3,{0x89,0x97,0x00,0xc0,0x4f,0x68,0x8d,0xde} }; + extern "C" const GUID __declspec(selectany) IID_CodeParameter = + { 0x0cfbc2bd,0x0d4e,0x11d3,{0x89,0x97,0x00,0xc0,0x4f,0x68,0x8d,0xde} }; + extern "C" const GUID __declspec(selectany) IID_CodeFunction = + { 0x0cfbc2b9,0x0d4e,0x11d3,{0x89,0x97,0x00,0xc0,0x4f,0x68,0x8d,0xde} }; + extern "C" const GUID __declspec(selectany) IID_CodeVariable = + { 0x0cfbc2ba,0x0d4e,0x11d3,{0x89,0x97,0x00,0xc0,0x4f,0x68,0x8d,0xde} }; + extern "C" const GUID __declspec(selectany) IID_CodeNamespace = + { 0x0cfbc2b8,0x0d4e,0x11d3,{0x89,0x97,0x00,0xc0,0x4f,0x68,0x8d,0xde} }; + extern "C" const GUID __declspec(selectany) IID_CodeEnum = + { 0xb1f42512,0x91cd,0x4d3a,{0x8b,0x25,0xa3,0x17,0xd8,0x03,0x2b,0x24} }; + extern "C" const GUID __declspec(selectany) IID_CodeClass = + { 0xb1f42514,0x91cd,0x4d3a,{0x8b,0x25,0xa3,0x17,0xd8,0x03,0x2b,0x24} }; + extern "C" const GUID __declspec(selectany) IID_CodeProperty = + { 0x0cfbc2bb,0x0d4e,0x11d3,{0x89,0x97,0x00,0xc0,0x4f,0x68,0x8d,0xde} }; + extern "C" const GUID __declspec(selectany) IID_CodeInterface = + { 0xb1f42510,0x91cd,0x4d3a,{0x8b,0x25,0xa3,0x17,0xd8,0x03,0x2b,0x24} }; + extern "C" const GUID __declspec(selectany) IID_CodeDelegate = + { 0xb1f42513,0x91cd,0x4d3a,{0x8b,0x25,0xa3,0x17,0xd8,0x03,0x2b,0x24} }; + extern "C" const GUID __declspec(selectany) IID_CodeStruct = + { 0xb1f42511,0x91cd,0x4d3a,{0x8b,0x25,0xa3,0x17,0xd8,0x03,0x2b,0x24} }; + extern "C" const GUID __declspec(selectany) IID_FileCodeModel = + { 0xed1a3f99,0x4477,0x11d3,{0x89,0xbf,0x00,0xc0,0x4f,0x68,0x8d,0xde} }; + extern "C" const GUID __declspec(selectany) IID_ContextAttributes = + { 0x33c5ebb8,0x244e,0x449d,{0x9c,0xee,0xfa,0xd7,0x0a,0x77,0x4e,0x59} }; + extern "C" const GUID __declspec(selectany) IID_ContextAttribute = + { 0x1a6e2cb3,0xb897,0x42eb,{0x96,0xbe,0xff,0x0f,0xdb,0x65,0xdb,0x2f} }; + extern "C" const GUID __declspec(selectany) IID_AddIn = + { 0x53a87fa1,0xce93,0x48bf,{0x95,0x8b,0xc6,0xda,0x79,0x3c,0x50,0x28} }; + extern "C" const GUID __declspec(selectany) IID_AddIns = + { 0x50590801,0xd13e,0x4404,{0x80,0xc2,0x5c,0xa3,0x0a,0x4d,0x0e,0xe8} }; + extern "C" const GUID __declspec(selectany) IID_OutputWindowPane = + { 0xffc9dfc4,0x61ca,0x4b0c,{0x83,0xc2,0x07,0x03,0xa2,0x4f,0x5c,0x16} }; + extern "C" const GUID __declspec(selectany) IID_OutputWindowPanes = + { 0xb02cf62a,0x9470,0x4308,{0xa5,0x21,0x96,0x75,0xfb,0xa3,0x95,0xab} }; + extern "C" const GUID __declspec(selectany) IID_OutputWindow = + { 0xeab0a63d,0xc3a8,0x496e,{0x9a,0xcf,0xa8,0x2c,0xef,0x6a,0x43,0xb3} }; + extern "C" const GUID __declspec(selectany) IID_TaskItem = + { 0x58e4d419,0x6b8c,0x4c63,{0x92,0xde,0x70,0x16,0x1c,0xd9,0x58,0x90} }; + extern "C" const GUID __declspec(selectany) IID_TaskItems = + { 0x4b51103d,0x513c,0x4773,{0xb5,0x6a,0x35,0x4d,0x09,0x28,0xfd,0x04} }; + extern "C" const GUID __declspec(selectany) IID_TaskList = + { 0x4e4f0569,0xe16a,0x4da1,{0x92,0xde,0x10,0x88,0x2a,0x4d,0xdd,0x8c} }; + extern "C" const GUID __declspec(selectany) IID_Process = + { 0x5c5a0070,0xf396,0x4e37,{0xa8,0x2a,0x1b,0x76,0x7e,0x27,0x2d,0xf9} }; + extern "C" const GUID __declspec(selectany) IID_Programs = + { 0xdc6a118a,0xbbab,0x11d2,{0x8a,0xd1,0x00,0xc0,0x4f,0x79,0xe4,0x79} }; + extern "C" const GUID __declspec(selectany) IID_Program = + { 0x6a38d87c,0xbba0,0x11d2,{0x8a,0xd1,0x00,0xc0,0x4f,0x79,0xe4,0x79} }; + extern "C" const GUID __declspec(selectany) IID_Threads = + { 0x6aa23fb4,0xbba1,0x11d2,{0x8a,0xd1,0x00,0xc0,0x4f,0x79,0xe4,0x79} }; + extern "C" const GUID __declspec(selectany) IID_Thread = + { 0x9407f466,0xbba1,0x11d2,{0x8a,0xd1,0x00,0xc0,0x4f,0x79,0xe4,0x79} }; + extern "C" const GUID __declspec(selectany) IID_StackFrames = + { 0x4ed85664,0xbba2,0x11d2,{0x8a,0xd1,0x00,0xc0,0x4f,0x79,0xe4,0x79} }; + extern "C" const GUID __declspec(selectany) IID_StackFrame = + { 0x1342d0d8,0xbba3,0x11d2,{0x8a,0xd1,0x00,0xc0,0x4f,0x79,0xe4,0x79} }; + extern "C" const GUID __declspec(selectany) IID_Expressions = + { 0x2685337a,0xbb9e,0x11d2,{0x8a,0xd1,0x00,0xc0,0x4f,0x79,0xe4,0x79} }; + extern "C" const GUID __declspec(selectany) IID_Expression = + { 0x27adc812,0xbb07,0x11d2,{0x8a,0xd1,0x00,0xc0,0x4f,0x79,0xe4,0x79} }; + extern "C" const GUID __declspec(selectany) IID_Debugger = + { 0x338fb9a0,0xbae5,0x11d2,{0x8a,0xd1,0x00,0xc0,0x4f,0x79,0xe4,0x79} }; + extern "C" const GUID __declspec(selectany) IID_Processes = + { 0x9f379969,0x5eac,0x4a54,{0xb2,0xbc,0x69,0x46,0xcf,0xfb,0x56,0xef} }; + extern "C" const GUID __declspec(selectany) IID_Breakpoints = + { 0x25968106,0xbafb,0x11d2,{0x8a,0xd1,0x00,0xc0,0x4f,0x79,0xe4,0x79} }; + extern "C" const GUID __declspec(selectany) IID_Breakpoint = + { 0x11c5114c,0xbb00,0x11d2,{0x8a,0xd1,0x00,0xc0,0x4f,0x79,0xe4,0x79} }; + extern "C" const GUID __declspec(selectany) IID_Languages = + { 0xa4f4246c,0xc131,0x11d2,{0x8a,0xd1,0x00,0xc0,0x4f,0x79,0xe4,0x79} }; + extern "C" const GUID __declspec(selectany) IID_Language = + { 0xb3ccfa68,0xc145,0x11d2,{0x8a,0xd1,0x00,0xc0,0x4f,0x79,0xe4,0x79} }; + extern "C" const GUID __declspec(selectany) IID__Solution = + { 0x26f6cc4b,0x7a48,0x4e4d,{0x8a,0xf5,0x9e,0x96,0x02,0x32,0xe0,0x5f} }; + extern "C" const GUID __declspec(selectany) IID_SolutionBuild = + { 0xa3c1c40c,0x9218,0x4d4c,{0x9d,0xaa,0x07,0x5f,0x64,0xf6,0x92,0x2c} }; + extern "C" const GUID __declspec(selectany) IID_SolutionConfiguration = + { 0x60aaad75,0xcb8d,0x4c62,{0x99,0x59,0x24,0xd6,0xa6,0xa5,0x0d,0xe7} }; + extern "C" const GUID __declspec(selectany) IID_SolutionConfigurations = + { 0x23e78ed7,0xc9e1,0x462d,{0x8b,0xc6,0x36,0x60,0x03,0x48,0x6e,0xd9} }; + extern "C" const GUID __declspec(selectany) IID_SolutionContexts = + { 0x0685b546,0xfb84,0x4917,{0xab,0x98,0x98,0xd4,0x0f,0x89,0x2d,0x61} }; + extern "C" const GUID __declspec(selectany) IID_SolutionContext = + { 0xfc6a1a82,0x9c8a,0x47bb,{0xa0,0x46,0x6e,0x96,0x5d,0xf5,0xa9,0x9b} }; + extern "C" const GUID __declspec(selectany) IID_BuildDependencies = + { 0xead260eb,0x1e5b,0x450a,{0xb6,0x28,0x4c,0xfa,0xda,0x11,0xb4,0xa1} }; + extern "C" const GUID __declspec(selectany) IID_BuildDependency = + { 0x9c5ceaac,0x062f,0x4434,{0xa2,0xed,0x78,0xab,0x4d,0x61,0x34,0xfe} }; + extern "C" const GUID __declspec(selectany) IID_Commands = + { 0xe6b96cac,0xb8c7,0x40ae,{0xb7,0x05,0x5c,0x81,0x87,0x8c,0x4a,0x9e} }; + extern "C" const GUID __declspec(selectany) IID_Command = + { 0x5fe10fb0,0x91a1,0x4e55,{0xba,0xaa,0xec,0xca,0xe5,0xcc,0xeb,0x94} }; + extern "C" const GUID __declspec(selectany) IID_SelectedItems = + { 0x6caa67cf,0x43ae,0x4184,{0xaa,0xab,0x02,0x00,0xdd,0xf6,0xb2,0x40} }; + extern "C" const GUID __declspec(selectany) IID_SelectedItem = + { 0x049d2cdf,0x3731,0x4cb6,{0xa2,0x33,0xbe,0x97,0xbc,0xe9,0x22,0xd3} }; + extern "C" const GUID __declspec(selectany) IID_SelectionContainer = + { 0x02273422,0x8dd4,0x4a9f,{0x8a,0x8b,0xd7,0x04,0x43,0xd5,0x10,0xf4} }; + extern "C" const GUID __declspec(selectany) IID_WindowConfigurations = + { 0xe577442a,0x98e1,0x46c5,{0xbd,0x2e,0xd2,0x58,0x07,0xec,0x81,0xce} }; + extern "C" const GUID __declspec(selectany) IID_WindowConfiguration = + { 0x41d02413,0x8a67,0x4c28,{0xa9,0x80,0xad,0x75,0x39,0xed,0x41,0x5d} }; + extern "C" const GUID __declspec(selectany) IID_ToolBox = + { 0x56fcd5af,0x7f17,0x4c5c,{0xaa,0x8d,0xae,0x2b,0xb2,0xdd,0xbf,0x38} }; + extern "C" const GUID __declspec(selectany) IID_ToolBoxTab = + { 0xce2def9e,0x3387,0x4bf2,{0x96,0x7b,0xa1,0xf7,0xf7,0x0d,0xf3,0x25} }; + extern "C" const GUID __declspec(selectany) IID_ToolBoxTabs = + { 0xcf177b52,0x4f2f,0x42a0,{0x8d,0xa3,0xce,0x78,0x67,0x9a,0x0d,0x2d} }; + extern "C" const GUID __declspec(selectany) IID_ToolBoxItems = + { 0x395c7dfb,0xf158,0x431c,{0x8f,0x43,0xdd,0xa8,0x3b,0x4e,0xf5,0x4e} }; + extern "C" const GUID __declspec(selectany) IID_ToolBoxItem = + { 0x46538d1b,0x4d81,0x4002,{0x8b,0xb4,0xdb,0xdb,0x65,0xba,0xbb,0x23} }; + extern "C" const GUID __declspec(selectany) IID_UIHierarchyItem = + { 0xfbd0d024,0x09cd,0x4d9f,{0x9e,0x2b,0xca,0xcd,0x62,0x84,0x26,0xa5} }; + extern "C" const GUID __declspec(selectany) IID_UIHierarchyItems = + { 0xdb8406b0,0xa916,0x449c,{0xa2,0x77,0xbb,0x04,0x02,0x8f,0x43,0x94} }; + extern "C" const GUID __declspec(selectany) IID_UIHierarchy = + { 0x72a2a2ef,0xc209,0x408c,{0xa3,0x77,0x76,0x87,0x17,0x74,0xad,0xb7} }; + +} // namespace EnvDTE + +#pragma pack(pop) diff --git a/Editor/COMIntegration/COMIntegration~/dte80a.tlh.meta b/Editor/COMIntegration/COMIntegration~/dte80a.tlh.meta new file mode 100644 index 0000000..923834a --- /dev/null +++ b/Editor/COMIntegration/COMIntegration~/dte80a.tlh.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: 97115cd910ade104a9d05d65a6b6b7d9 +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Editor/COMIntegration/COMIntegration~/release-build.txt b/Editor/COMIntegration/COMIntegration~/release-build.txt new file mode 100644 index 0000000..28d89ce --- /dev/null +++ b/Editor/COMIntegration/COMIntegration~/release-build.txt @@ -0,0 +1 @@ +cl /EHsc /std:c++17 COMIntegration.cpp /link Shlwapi.lib /out:"..\Release\COMIntegration.exe" diff --git a/Editor/COMIntegration/COMIntegration~/release-build.txt.meta b/Editor/COMIntegration/COMIntegration~/release-build.txt.meta new file mode 100644 index 0000000..f1bd9d7 --- /dev/null +++ b/Editor/COMIntegration/COMIntegration~/release-build.txt.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: 3b44687349be79f4184ba013fb6ffa0c +TextScriptImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Editor/COMIntegration/Release/COMIntegration.exe b/Editor/COMIntegration/Release/COMIntegration.exe index 2ead0a79f8cbbda5128b8c8b83c81f0730d12ece..4930d8ca1de064e7cd9ba576a87c183ac33709f2 100644 GIT binary patch delta 107663 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

`|YrXd0i_d|BlFn^hk)gfn4{0)EY8HOl>$^oEH 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 E55s1lTmS$7 delta 110368 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 IuRmG)2Z@CqwEzGB diff --git a/Editor/ProjectGeneration/AssemblyNameProvider.cs b/Editor/ProjectGeneration/AssemblyNameProvider.cs index 90787ad..7dba7c3 100644 --- a/Editor/ProjectGeneration/AssemblyNameProvider.cs +++ b/Editor/ProjectGeneration/AssemblyNameProvider.cs @@ -30,6 +30,8 @@ namespace Microsoft.Unity.VisualStudio.Editor public class AssemblyNameProvider : IAssemblyNameProvider { + private readonly Dictionary m_PackageInfoCache = new Dictionary(); + ProjectGenerationFlag m_ProjectGenerationFlag = (ProjectGenerationFlag)EditorPrefs.GetInt( "unity_project_generation_flag", (int)(ProjectGenerationFlag.Local | ProjectGenerationFlag.Embedded)); @@ -55,55 +57,35 @@ namespace Microsoft.Unity.VisualStudio.Editor public IEnumerable GetAssemblies(Func shouldFileBePartOfSolution) { - foreach (var assembly in CompilationPipeline.GetAssemblies()) + IEnumerable assemblies = GetAssembliesByType(AssembliesType.Editor, shouldFileBePartOfSolution, @"Temp\Bin\Debug\"); + + if (!ProjectGenerationFlag.HasFlag(ProjectGenerationFlag.PlayerAssemblies)) + { + return assemblies; + } + var playerAssemblies = GetAssembliesByType(AssembliesType.Player, shouldFileBePartOfSolution, @"Temp\Bin\Debug\Player\"); + return assemblies.Concat(playerAssemblies); + } + + private static IEnumerable GetAssembliesByType(AssembliesType type, Func shouldFileBePartOfSolution, string outputPath) + { + foreach (var assembly in CompilationPipeline.GetAssemblies(type)) { if (assembly.sourceFiles.Any(shouldFileBePartOfSolution)) { - var options = new ScriptCompilerOptions - { - ResponseFiles = assembly.compilerOptions.ResponseFiles, - AllowUnsafeCode = assembly.compilerOptions.AllowUnsafeCode, - ApiCompatibilityLevel = assembly.compilerOptions.ApiCompatibilityLevel - }; - - yield return new Assembly(assembly.name, @"Temp\Bin\Debug\", - assembly.sourceFiles, new[] { "DEBUG", "TRACE" }.Concat(assembly.defines).Concat(EditorUserBuildSettings.activeScriptCompilationDefines).ToArray(), + yield return new Assembly( + assembly.name, + outputPath, + assembly.sourceFiles, + assembly.defines, assembly.assemblyReferences, assembly.compiledAssemblyReferences, assembly.flags, + assembly.compilerOptions #if UNITY_2020_2_OR_NEWER - options, - assembly.rootNamespace); -#else - options); -#endif - } - } - - if (ProjectGenerationFlag.HasFlag(ProjectGenerationFlag.PlayerAssemblies)) - { - foreach (var assembly in CompilationPipeline.GetAssemblies(AssembliesType.Player).Where(assembly => assembly.sourceFiles.Any(shouldFileBePartOfSolution))) - { - var options = new ScriptCompilerOptions - { - ResponseFiles = assembly.compilerOptions.ResponseFiles, - AllowUnsafeCode = assembly.compilerOptions.AllowUnsafeCode, - ApiCompatibilityLevel = assembly.compilerOptions.ApiCompatibilityLevel - }; - - yield return - new Assembly(assembly.name, @"Temp\Bin\Debug\Player\", - assembly.sourceFiles, - new[] { "DEBUG", "TRACE" }.Concat(assembly.defines).ToArray(), - assembly.assemblyReferences, - assembly.compiledAssemblyReferences, - assembly.flags, -#if UNITY_2020_2_OR_NEWER - options, - assembly.rootNamespace); -#else - options); + , assembly.rootNamespace #endif + ); } } } @@ -118,9 +100,39 @@ namespace Microsoft.Unity.VisualStudio.Editor return AssetDatabase.GetAllAssetPaths(); } + private static string ResolvePotentialParentPackageAssetPath(string assetPath) + { + const string packagesPrefix = "packages/"; + if (!assetPath.StartsWith(packagesPrefix, StringComparison.OrdinalIgnoreCase)) + { + return null; + } + + var followupSeparator = assetPath.IndexOf('/', packagesPrefix.Length); + if (followupSeparator == -1) + { + return assetPath.ToLowerInvariant(); + } + + return assetPath.Substring(0, followupSeparator).ToLowerInvariant(); + } + public UnityEditor.PackageManager.PackageInfo FindForAssetPath(string assetPath) { - return UnityEditor.PackageManager.PackageInfo.FindForAssetPath(assetPath); + var parentPackageAssetPath = ResolvePotentialParentPackageAssetPath(assetPath); + if (parentPackageAssetPath == null) + { + return null; + } + + if (m_PackageInfoCache.TryGetValue(parentPackageAssetPath, out var cachedPackageInfo)) + { + return cachedPackageInfo; + } + + var result = UnityEditor.PackageManager.PackageInfo.FindForAssetPath(parentPackageAssetPath); + m_PackageInfoCache[parentPackageAssetPath] = result; + return result; } public bool IsInternalizedPackagePath(string path) @@ -177,6 +189,11 @@ namespace Microsoft.Unity.VisualStudio.Editor } } + internal void ResetPackageInfoCache() + { + m_PackageInfoCache.Clear(); + } + public void ResetProjectGenerationFlag() { ProjectGenerationFlag = ProjectGenerationFlag.None; diff --git a/Editor/ProjectGeneration/ProjectGeneration.cs b/Editor/ProjectGeneration/ProjectGeneration.cs index c96f26b..2e61e10 100644 --- a/Editor/ProjectGeneration/ProjectGeneration.cs +++ b/Editor/ProjectGeneration/ProjectGeneration.cs @@ -104,10 +104,6 @@ namespace Microsoft.Unity.VisualStudio.Editor { SetupProjectSupportedExtensions(); - // See https://devblogs.microsoft.com/setup/configure-visual-studio-across-your-organization-with-vsconfig/ - // We create a .vsconfig file to make sure our ManagedGame workload is installed - CreateVsConfigIfNotFound(); - // Don't sync if we haven't synced before if (HasSolutionBeenGenerated() && HasFilesBeenModified(affectedFiles, reimportedFiles)) { @@ -161,6 +157,13 @@ namespace Microsoft.Unity.VisualStudio.Editor RefreshCurrentInstallation(); SetupProjectSupportedExtensions(); + + (m_AssemblyNameProvider as AssemblyNameProvider)?.ResetPackageInfoCache(); + + // See https://devblogs.microsoft.com/setup/configure-visual-studio-across-your-organization-with-vsconfig/ + // We create a .vsconfig file to make sure our ManagedGame workload is installed + CreateVsConfigIfNotFound(); + var externalCodeAlreadyGeneratedProjects = OnPreGeneratingCSProjectFiles(); if (!externalCodeAlreadyGeneratedProjects) @@ -322,7 +325,7 @@ namespace Microsoft.Unity.VisualStudio.Editor stringBuilders[assemblyName] = projectBuilder; } - projectBuilder.Append(" ").Append(k_WindowsNewline); + projectBuilder.Append(" ").Append(k_WindowsNewline); } } @@ -367,6 +370,7 @@ namespace Microsoft.Unity.VisualStudio.Editor { return TypeCache .GetTypesDerivedFrom() + .Where(t => t.Assembly.GetName().Name != "SyntaxTree.VisualStudio.Unity.Bridge") // never call into the bridge if loaded with the package .Select(t => t.GetMethod(name, SR.BindingFlags.Public | SR.BindingFlags.NonPublic | SR.BindingFlags.Static)) .Where(m => m != null); } @@ -466,12 +470,19 @@ namespace Microsoft.Unity.VisualStudio.Editor } projectBuilder.Append(@" ").Append(k_WindowsNewline); - projectBuilder.Append(@" ").Append(k_WindowsNewline); - // Append additional non-script files that should be included in project generation. if (allAssetsProjectParts.TryGetValue(assembly.name, out var additionalAssetsForProject)) + { + projectBuilder.Append(@" ").Append(k_WindowsNewline); + projectBuilder.Append(additionalAssetsForProject); + projectBuilder.Append(@" ").Append(k_WindowsNewline); + + } + + projectBuilder.Append(@" ").Append(k_WindowsNewline); + var responseRefs = responseFilesData.SelectMany(x => x.FullPathReferences.Select(r => r)); var internalAssemblyReferences = assembly.assemblyReferences .Where(i => !i.sourceFiles.Any(ShouldFileBePartOfSolution)).Select(i => i.outputPath); diff --git a/Editor/VisualStudioEditor.cs b/Editor/VisualStudioEditor.cs index c1b0dce..3ba37cf 100644 --- a/Editor/VisualStudioEditor.cs +++ b/Editor/VisualStudioEditor.cs @@ -308,7 +308,7 @@ namespace Microsoft.Unity.VisualStudio.Editor StartInfo = new ProcessStartInfo { FileName = progpath, - Arguments = $"\"{CodeEditor.CurrentEditorInstallation}\" \"{absolutePath}\" {solution} {line}", + Arguments = $"\"{CodeEditor.CurrentEditorInstallation}\" {solution} \"{absolutePath}\" {line}", CreateNoWindow = true, UseShellExecute = false, RedirectStandardOutput = true, diff --git a/Editor/VisualStudioInstallation.cs b/Editor/VisualStudioInstallation.cs index a4ede5a..e1602c7 100644 --- a/Editor/VisualStudioInstallation.cs +++ b/Editor/VisualStudioInstallation.cs @@ -4,7 +4,6 @@ *--------------------------------------------------------------------------------------------*/ using System; using System.IO; -using System.Linq; using Microsoft.Win32; using Unity.CodeEditor; using IOPath = System.IO.Path; @@ -78,7 +77,7 @@ namespace Microsoft.Unity.VisualStudio.Editor if (versions != null) { - foreach(var entry in versions) + foreach (var entry in versions) { if (Version >= entry.IdeVersion) return entry.LanguageVersion; @@ -86,7 +85,7 @@ namespace Microsoft.Unity.VisualStudio.Editor } // default to 7.0 given we support at least VS 2017 - return new Version(7,0); + return new Version(7, 0); } } @@ -105,31 +104,37 @@ namespace Microsoft.Unity.VisualStudio.Editor } } + private string GetWindowsBridgeFromRegistry() + { + var keyName = $"Software\\Microsoft\\Microsoft Visual Studio {Version.Major}.0 Tools for Unity"; + const string valueName = "UnityExtensionPath"; + + var bridge = ReadRegistry(Registry.CurrentUser, keyName, valueName); + if (string.IsNullOrEmpty(bridge)) + bridge = ReadRegistry(Registry.LocalMachine, keyName, valueName); + + return bridge; + } + // We only use this to find analyzers, we do not need to load this assembly anymore - private string GetBridgeLocation() + private string GetExtensionPath() { if (VisualStudioEditor.IsWindows) { - // Registry, using legacy bridge location - var keyName = $"Software\\Microsoft\\Microsoft Visual Studio {Version.Major}.0 Tools for Unity"; - const string valueName = "UnityExtensionPath"; + const string extensionName = "Visual Studio Tools for Unity"; + const string extensionAssembly = "SyntaxTree.VisualStudio.Unity.dll"; - var bridge = ReadRegistry(Registry.CurrentUser, keyName, valueName); - if (string.IsNullOrEmpty(bridge)) - bridge = ReadRegistry(Registry.LocalMachine, keyName, valueName); + var vsDirectory = IOPath.GetDirectoryName(Path); + var vstuDirectory = IOPath.Combine(vsDirectory, "Extensions", "Microsoft", extensionName); - return bridge; + if (File.Exists(IOPath.Combine(vstuDirectory, extensionAssembly))) + return vstuDirectory; } if (VisualStudioEditor.IsOSX) { - // Environment, useful when developing UnityVS for Mac - var bridge = Environment.GetEnvironmentVariable("VSTUM_BRIDGE"); - if (!string.IsNullOrEmpty(bridge) && File.Exists(bridge)) - return bridge; - - const string addinBridge = "Editor/SyntaxTree.VisualStudio.Unity.Bridge.dll"; const string addinName = "MonoDevelop.Unity"; + const string addinAssembly = addinName + ".dll"; // user addins repository var localAddins = IOPath.Combine( @@ -138,38 +143,54 @@ namespace Microsoft.Unity.VisualStudio.Editor // In the user addins repository, the addins are suffixed by their versions, like `MonoDevelop.Unity.1.0` // When installing another local user addin, MD will remove files inside the folder - // So we browse all VSTUM addins, and return the one with a bridge, which is the one MD will load + // So we browse all VSTUM addins, and return the one with an addin assembly if (Directory.Exists(localAddins)) { foreach (var folder in Directory.GetDirectories(localAddins, addinName + "*", SearchOption.TopDirectoryOnly)) { - bridge = IOPath.Combine(folder, addinBridge); - if (File.Exists(bridge)) - return bridge; + if (File.Exists(IOPath.Combine(folder, addinAssembly))) + return folder; } } // Check in Visual Studio.app/ // In that case the name of the addin is used - bridge = IOPath.Combine(Path, $"Contents/Resources/lib/monodevelop/AddIns/{addinName}/{addinBridge}"); - if (File.Exists(bridge)) - return bridge; + var addinPath = IOPath.Combine(Path, $"Contents/Resources/lib/monodevelop/AddIns/{addinName}"); + if (File.Exists(IOPath.Combine(addinPath, addinAssembly))) + return addinPath; } return null; } + private static string[] GetAnalyzers(string path) + { + var analyzersDirectory = IOPath.GetFullPath(IOPath.Combine(path, "Analyzers")); + + if (Directory.Exists(analyzersDirectory)) + return Directory.GetFiles(analyzersDirectory, "*Analyzers.dll", SearchOption.AllDirectories); + + return Array.Empty(); + } + public string[] GetAnalyzers() { - var bridge = GetBridgeLocation(); + var vstuPath = GetExtensionPath(); + if (string.IsNullOrEmpty(vstuPath)) + return Array.Empty(); - if (!string.IsNullOrEmpty(bridge)) + if (VisualStudioEditor.IsOSX) + return GetAnalyzers(vstuPath); + + if (VisualStudioEditor.IsWindows) { - var baseLocation = IOPath.Combine(IOPath.GetDirectoryName(bridge), ".."); - var analyzerLocation = IOPath.GetFullPath(IOPath.Combine(baseLocation, "Analyzers")); + var analyzers = GetAnalyzers(vstuPath); + if (analyzers?.Length > 0) + return analyzers; - if (Directory.Exists(analyzerLocation)) - return Directory.GetFiles(analyzerLocation, "*Analyzers.dll", SearchOption.AllDirectories); + var bridge = GetWindowsBridgeFromRegistry(); + if (File.Exists(bridge)) + return GetAnalyzers(IOPath.Combine(IOPath.GetDirectoryName(bridge), "..")); } // Local assets diff --git a/package.json b/package.json index df34025..db7b9b9 100644 --- a/package.json +++ b/package.json @@ -2,21 +2,21 @@ "name": "com.unity.ide.visualstudio", "displayName": "Visual Studio Editor", "description": "Code editor integration for supporting Visual Studio as code editor for unity. Adds support for generating csproj files for intellisense purposes, auto discovery of installations, etc.", - "version": "2.0.7", - "unity": "2020.1", - "unityRelease": "0a12", + "version": "2.0.8", + "unity": "2019.4", + "unityRelease": "21f1", "dependencies": { "com.unity.test-framework": "1.1.9" }, "relatedPackages": { - "com.unity.ide.visualstudio.tests": "2.0.7" + "com.unity.ide.visualstudio.tests": "2.0.8" }, "upmCi": { - "footprint": "b6515ac9d75224fe45e288270d26a9e031c550a8" + "footprint": "c51cc3db630d4f769464e8f12c2154af3ca5242c" }, "repository": { "url": "https://github.cds.internal.unity3d.com/unity/com.unity.ide.visualstudio.git", "type": "git", - "revision": "dec282022c7a95fada560c36f53da9dd155a142c" + "revision": "5cdf5d932e6ecbbd83bbe6a40eec2a94b4979501" } }