From a8a1e0d6f99c2b902a8f81d3d7f3503c506e8171 Mon Sep 17 00:00:00 2001 From: Rob Mensching Date: Tue, 4 May 2021 22:50:56 -0700 Subject: Move VisualStudio.wixext into ext --- .../VisualStudio/wixext/Symbols/HelpFileSymbol.cs | 95 +++ .../wixext/Symbols/HelpFileToNamespaceSymbol.cs | 55 ++ .../wixext/Symbols/HelpFilterSymbol.cs | 55 ++ .../wixext/Symbols/HelpFilterToNamespaceSymbol.cs | 55 ++ .../wixext/Symbols/HelpNamespaceSymbol.cs | 63 ++ .../wixext/Symbols/HelpPluginSymbol.cs | 79 ++ .../wixext/Symbols/VSSymbolDefinitions.cs | 59 ++ src/ext/VisualStudio/wixext/VSCompiler.cs | 828 +++++++++++++++++++++ src/ext/VisualStudio/wixext/VSDecompiler.cs | 298 ++++++++ src/ext/VisualStudio/wixext/VSExtensionData.cs | 27 + src/ext/VisualStudio/wixext/VSExtensionFactory.cs | 18 + src/ext/VisualStudio/wixext/VSTableDefinitions.cs | 97 +++ .../VSWindowsInstallerBackendBinderExtension.cs | 13 + .../wixext/WixToolset.VisualStudio.wixext.csproj | 30 + .../wixext/WixToolset.VisualStudio.wixext.nuspec | 23 + .../wixext/WixToolset.VisualStudio.wixext.targets | 8 + ...ixToolset.VisualStudio.wixext.v3.ncrunchproject | 7 + 17 files changed, 1810 insertions(+) create mode 100644 src/ext/VisualStudio/wixext/Symbols/HelpFileSymbol.cs create mode 100644 src/ext/VisualStudio/wixext/Symbols/HelpFileToNamespaceSymbol.cs create mode 100644 src/ext/VisualStudio/wixext/Symbols/HelpFilterSymbol.cs create mode 100644 src/ext/VisualStudio/wixext/Symbols/HelpFilterToNamespaceSymbol.cs create mode 100644 src/ext/VisualStudio/wixext/Symbols/HelpNamespaceSymbol.cs create mode 100644 src/ext/VisualStudio/wixext/Symbols/HelpPluginSymbol.cs create mode 100644 src/ext/VisualStudio/wixext/Symbols/VSSymbolDefinitions.cs create mode 100644 src/ext/VisualStudio/wixext/VSCompiler.cs create mode 100644 src/ext/VisualStudio/wixext/VSDecompiler.cs create mode 100644 src/ext/VisualStudio/wixext/VSExtensionData.cs create mode 100644 src/ext/VisualStudio/wixext/VSExtensionFactory.cs create mode 100644 src/ext/VisualStudio/wixext/VSTableDefinitions.cs create mode 100644 src/ext/VisualStudio/wixext/VSWindowsInstallerBackendBinderExtension.cs create mode 100644 src/ext/VisualStudio/wixext/WixToolset.VisualStudio.wixext.csproj create mode 100644 src/ext/VisualStudio/wixext/WixToolset.VisualStudio.wixext.nuspec create mode 100644 src/ext/VisualStudio/wixext/WixToolset.VisualStudio.wixext.targets create mode 100644 src/ext/VisualStudio/wixext/WixToolset.VisualStudio.wixext.v3.ncrunchproject (limited to 'src/ext/VisualStudio/wixext') diff --git a/src/ext/VisualStudio/wixext/Symbols/HelpFileSymbol.cs b/src/ext/VisualStudio/wixext/Symbols/HelpFileSymbol.cs new file mode 100644 index 00000000..8078f4ab --- /dev/null +++ b/src/ext/VisualStudio/wixext/Symbols/HelpFileSymbol.cs @@ -0,0 +1,95 @@ +// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information. + +namespace WixToolset.VisualStudio +{ + using WixToolset.Data; + using WixToolset.VisualStudio.Symbols; + + public static partial class VSSymbolDefinitions + { + public static readonly IntermediateSymbolDefinition HelpFile = new IntermediateSymbolDefinition( + VSSymbolDefinitionType.HelpFile.ToString(), + new[] + { + new IntermediateFieldDefinition(nameof(HelpFileSymbolFields.HelpFileName), IntermediateFieldType.String), + new IntermediateFieldDefinition(nameof(HelpFileSymbolFields.LangID), IntermediateFieldType.Number), + new IntermediateFieldDefinition(nameof(HelpFileSymbolFields.HxSFileRef), IntermediateFieldType.String), + new IntermediateFieldDefinition(nameof(HelpFileSymbolFields.HxIFileRef), IntermediateFieldType.String), + new IntermediateFieldDefinition(nameof(HelpFileSymbolFields.HxQFileRef), IntermediateFieldType.String), + new IntermediateFieldDefinition(nameof(HelpFileSymbolFields.HxRFileRef), IntermediateFieldType.String), + new IntermediateFieldDefinition(nameof(HelpFileSymbolFields.SamplesFileRef), IntermediateFieldType.String), + }, + typeof(HelpFileSymbol)); + } +} + +namespace WixToolset.VisualStudio.Symbols +{ + using WixToolset.Data; + + public enum HelpFileSymbolFields + { + HelpFileName, + LangID, + HxSFileRef, + HxIFileRef, + HxQFileRef, + HxRFileRef, + SamplesFileRef, + } + + public class HelpFileSymbol : IntermediateSymbol + { + public HelpFileSymbol() : base(VSSymbolDefinitions.HelpFile, null, null) + { + } + + public HelpFileSymbol(SourceLineNumber sourceLineNumber, Identifier id = null) : base(VSSymbolDefinitions.HelpFile, sourceLineNumber, id) + { + } + + public IntermediateField this[HelpFileSymbolFields index] => this.Fields[(int)index]; + + public string HelpFileName + { + get => this.Fields[(int)HelpFileSymbolFields.HelpFileName].AsString(); + set => this.Set((int)HelpFileSymbolFields.HelpFileName, value); + } + + public int? LangID + { + get => this.Fields[(int)HelpFileSymbolFields.LangID].AsNullableNumber(); + set => this.Set((int)HelpFileSymbolFields.LangID, value); + } + + public string HxSFileRef + { + get => this.Fields[(int)HelpFileSymbolFields.HxSFileRef].AsString(); + set => this.Set((int)HelpFileSymbolFields.HxSFileRef, value); + } + + public string HxIFileRef + { + get => this.Fields[(int)HelpFileSymbolFields.HxIFileRef].AsString(); + set => this.Set((int)HelpFileSymbolFields.HxIFileRef, value); + } + + public string HxQFileRef + { + get => this.Fields[(int)HelpFileSymbolFields.HxQFileRef].AsString(); + set => this.Set((int)HelpFileSymbolFields.HxQFileRef, value); + } + + public string HxRFileRef + { + get => this.Fields[(int)HelpFileSymbolFields.HxRFileRef].AsString(); + set => this.Set((int)HelpFileSymbolFields.HxRFileRef, value); + } + + public string SamplesFileRef + { + get => this.Fields[(int)HelpFileSymbolFields.SamplesFileRef].AsString(); + set => this.Set((int)HelpFileSymbolFields.SamplesFileRef, value); + } + } +} \ No newline at end of file diff --git a/src/ext/VisualStudio/wixext/Symbols/HelpFileToNamespaceSymbol.cs b/src/ext/VisualStudio/wixext/Symbols/HelpFileToNamespaceSymbol.cs new file mode 100644 index 00000000..f18d6701 --- /dev/null +++ b/src/ext/VisualStudio/wixext/Symbols/HelpFileToNamespaceSymbol.cs @@ -0,0 +1,55 @@ +// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information. + +namespace WixToolset.VisualStudio +{ + using WixToolset.Data; + using WixToolset.VisualStudio.Symbols; + + public static partial class VSSymbolDefinitions + { + public static readonly IntermediateSymbolDefinition HelpFileToNamespace = new IntermediateSymbolDefinition( + VSSymbolDefinitionType.HelpFileToNamespace.ToString(), + new[] + { + new IntermediateFieldDefinition(nameof(HelpFileToNamespaceSymbolFields.HelpFileRef), IntermediateFieldType.String), + new IntermediateFieldDefinition(nameof(HelpFileToNamespaceSymbolFields.HelpNamespaceRef), IntermediateFieldType.String), + }, + typeof(HelpFileToNamespaceSymbol)); + } +} + +namespace WixToolset.VisualStudio.Symbols +{ + using WixToolset.Data; + + public enum HelpFileToNamespaceSymbolFields + { + HelpFileRef, + HelpNamespaceRef, + } + + public class HelpFileToNamespaceSymbol : IntermediateSymbol + { + public HelpFileToNamespaceSymbol() : base(VSSymbolDefinitions.HelpFileToNamespace, null, null) + { + } + + public HelpFileToNamespaceSymbol(SourceLineNumber sourceLineNumber, Identifier id = null) : base(VSSymbolDefinitions.HelpFileToNamespace, sourceLineNumber, id) + { + } + + public IntermediateField this[HelpFileToNamespaceSymbolFields index] => this.Fields[(int)index]; + + public string HelpFileRef + { + get => this.Fields[(int)HelpFileToNamespaceSymbolFields.HelpFileRef].AsString(); + set => this.Set((int)HelpFileToNamespaceSymbolFields.HelpFileRef, value); + } + + public string HelpNamespaceRef + { + get => this.Fields[(int)HelpFileToNamespaceSymbolFields.HelpNamespaceRef].AsString(); + set => this.Set((int)HelpFileToNamespaceSymbolFields.HelpNamespaceRef, value); + } + } +} \ No newline at end of file diff --git a/src/ext/VisualStudio/wixext/Symbols/HelpFilterSymbol.cs b/src/ext/VisualStudio/wixext/Symbols/HelpFilterSymbol.cs new file mode 100644 index 00000000..9deb47d0 --- /dev/null +++ b/src/ext/VisualStudio/wixext/Symbols/HelpFilterSymbol.cs @@ -0,0 +1,55 @@ +// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information. + +namespace WixToolset.VisualStudio +{ + using WixToolset.Data; + using WixToolset.VisualStudio.Symbols; + + public static partial class VSSymbolDefinitions + { + public static readonly IntermediateSymbolDefinition HelpFilter = new IntermediateSymbolDefinition( + VSSymbolDefinitionType.HelpFilter.ToString(), + new[] + { + new IntermediateFieldDefinition(nameof(HelpFilterSymbolFields.Description), IntermediateFieldType.String), + new IntermediateFieldDefinition(nameof(HelpFilterSymbolFields.QueryString), IntermediateFieldType.String), + }, + typeof(HelpFilterSymbol)); + } +} + +namespace WixToolset.VisualStudio.Symbols +{ + using WixToolset.Data; + + public enum HelpFilterSymbolFields + { + Description, + QueryString, + } + + public class HelpFilterSymbol : IntermediateSymbol + { + public HelpFilterSymbol() : base(VSSymbolDefinitions.HelpFilter, null, null) + { + } + + public HelpFilterSymbol(SourceLineNumber sourceLineNumber, Identifier id = null) : base(VSSymbolDefinitions.HelpFilter, sourceLineNumber, id) + { + } + + public IntermediateField this[HelpFilterSymbolFields index] => this.Fields[(int)index]; + + public string Description + { + get => this.Fields[(int)HelpFilterSymbolFields.Description].AsString(); + set => this.Set((int)HelpFilterSymbolFields.Description, value); + } + + public string QueryString + { + get => this.Fields[(int)HelpFilterSymbolFields.QueryString].AsString(); + set => this.Set((int)HelpFilterSymbolFields.QueryString, value); + } + } +} \ No newline at end of file diff --git a/src/ext/VisualStudio/wixext/Symbols/HelpFilterToNamespaceSymbol.cs b/src/ext/VisualStudio/wixext/Symbols/HelpFilterToNamespaceSymbol.cs new file mode 100644 index 00000000..f3d21289 --- /dev/null +++ b/src/ext/VisualStudio/wixext/Symbols/HelpFilterToNamespaceSymbol.cs @@ -0,0 +1,55 @@ +// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information. + +namespace WixToolset.VisualStudio +{ + using WixToolset.Data; + using WixToolset.VisualStudio.Symbols; + + public static partial class VSSymbolDefinitions + { + public static readonly IntermediateSymbolDefinition HelpFilterToNamespace = new IntermediateSymbolDefinition( + VSSymbolDefinitionType.HelpFilterToNamespace.ToString(), + new[] + { + new IntermediateFieldDefinition(nameof(HelpFilterToNamespaceSymbolFields.HelpFilterRef), IntermediateFieldType.String), + new IntermediateFieldDefinition(nameof(HelpFilterToNamespaceSymbolFields.HelpNamespaceRef), IntermediateFieldType.String), + }, + typeof(HelpFilterToNamespaceSymbol)); + } +} + +namespace WixToolset.VisualStudio.Symbols +{ + using WixToolset.Data; + + public enum HelpFilterToNamespaceSymbolFields + { + HelpFilterRef, + HelpNamespaceRef, + } + + public class HelpFilterToNamespaceSymbol : IntermediateSymbol + { + public HelpFilterToNamespaceSymbol() : base(VSSymbolDefinitions.HelpFilterToNamespace, null, null) + { + } + + public HelpFilterToNamespaceSymbol(SourceLineNumber sourceLineNumber, Identifier id = null) : base(VSSymbolDefinitions.HelpFilterToNamespace, sourceLineNumber, id) + { + } + + public IntermediateField this[HelpFilterToNamespaceSymbolFields index] => this.Fields[(int)index]; + + public string HelpFilterRef + { + get => this.Fields[(int)HelpFilterToNamespaceSymbolFields.HelpFilterRef].AsString(); + set => this.Set((int)HelpFilterToNamespaceSymbolFields.HelpFilterRef, value); + } + + public string HelpNamespaceRef + { + get => this.Fields[(int)HelpFilterToNamespaceSymbolFields.HelpNamespaceRef].AsString(); + set => this.Set((int)HelpFilterToNamespaceSymbolFields.HelpNamespaceRef, value); + } + } +} \ No newline at end of file diff --git a/src/ext/VisualStudio/wixext/Symbols/HelpNamespaceSymbol.cs b/src/ext/VisualStudio/wixext/Symbols/HelpNamespaceSymbol.cs new file mode 100644 index 00000000..8d2c2f80 --- /dev/null +++ b/src/ext/VisualStudio/wixext/Symbols/HelpNamespaceSymbol.cs @@ -0,0 +1,63 @@ +// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information. + +namespace WixToolset.VisualStudio +{ + using WixToolset.Data; + using WixToolset.VisualStudio.Symbols; + + public static partial class VSSymbolDefinitions + { + public static readonly IntermediateSymbolDefinition HelpNamespace = new IntermediateSymbolDefinition( + VSSymbolDefinitionType.HelpNamespace.ToString(), + new[] + { + new IntermediateFieldDefinition(nameof(HelpNamespaceSymbolFields.NamespaceName), IntermediateFieldType.String), + new IntermediateFieldDefinition(nameof(HelpNamespaceSymbolFields.CollectionFileRef), IntermediateFieldType.String), + new IntermediateFieldDefinition(nameof(HelpNamespaceSymbolFields.Description), IntermediateFieldType.String), + }, + typeof(HelpNamespaceSymbol)); + } +} + +namespace WixToolset.VisualStudio.Symbols +{ + using WixToolset.Data; + + public enum HelpNamespaceSymbolFields + { + NamespaceName, + CollectionFileRef, + Description, + } + + public class HelpNamespaceSymbol : IntermediateSymbol + { + public HelpNamespaceSymbol() : base(VSSymbolDefinitions.HelpNamespace, null, null) + { + } + + public HelpNamespaceSymbol(SourceLineNumber sourceLineNumber, Identifier id = null) : base(VSSymbolDefinitions.HelpNamespace, sourceLineNumber, id) + { + } + + public IntermediateField this[HelpNamespaceSymbolFields index] => this.Fields[(int)index]; + + public string NamespaceName + { + get => this.Fields[(int)HelpNamespaceSymbolFields.NamespaceName].AsString(); + set => this.Set((int)HelpNamespaceSymbolFields.NamespaceName, value); + } + + public string CollectionFileRef + { + get => this.Fields[(int)HelpNamespaceSymbolFields.CollectionFileRef].AsString(); + set => this.Set((int)HelpNamespaceSymbolFields.CollectionFileRef, value); + } + + public string Description + { + get => this.Fields[(int)HelpNamespaceSymbolFields.Description].AsString(); + set => this.Set((int)HelpNamespaceSymbolFields.Description, value); + } + } +} \ No newline at end of file diff --git a/src/ext/VisualStudio/wixext/Symbols/HelpPluginSymbol.cs b/src/ext/VisualStudio/wixext/Symbols/HelpPluginSymbol.cs new file mode 100644 index 00000000..a452fbd5 --- /dev/null +++ b/src/ext/VisualStudio/wixext/Symbols/HelpPluginSymbol.cs @@ -0,0 +1,79 @@ +// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information. + +namespace WixToolset.VisualStudio +{ + using WixToolset.Data; + using WixToolset.VisualStudio.Symbols; + + public static partial class VSSymbolDefinitions + { + public static readonly IntermediateSymbolDefinition HelpPlugin = new IntermediateSymbolDefinition( + VSSymbolDefinitionType.HelpPlugin.ToString(), + new[] + { + new IntermediateFieldDefinition(nameof(HelpPluginSymbolFields.HelpNamespaceRef), IntermediateFieldType.String), + new IntermediateFieldDefinition(nameof(HelpPluginSymbolFields.ParentHelpNamespaceRef), IntermediateFieldType.String), + new IntermediateFieldDefinition(nameof(HelpPluginSymbolFields.HxTFileRef), IntermediateFieldType.String), + new IntermediateFieldDefinition(nameof(HelpPluginSymbolFields.HxAFileRef), IntermediateFieldType.String), + new IntermediateFieldDefinition(nameof(HelpPluginSymbolFields.ParentHxTFileRef), IntermediateFieldType.String), + }, + typeof(HelpPluginSymbol)); + } +} + +namespace WixToolset.VisualStudio.Symbols +{ + using WixToolset.Data; + + public enum HelpPluginSymbolFields + { + HelpNamespaceRef, + ParentHelpNamespaceRef, + HxTFileRef, + HxAFileRef, + ParentHxTFileRef, + } + + public class HelpPluginSymbol : IntermediateSymbol + { + public HelpPluginSymbol() : base(VSSymbolDefinitions.HelpPlugin, null, null) + { + } + + public HelpPluginSymbol(SourceLineNumber sourceLineNumber, Identifier id = null) : base(VSSymbolDefinitions.HelpPlugin, sourceLineNumber, id) + { + } + + public IntermediateField this[HelpPluginSymbolFields index] => this.Fields[(int)index]; + + public string HelpNamespaceRef + { + get => this.Fields[(int)HelpPluginSymbolFields.HelpNamespaceRef].AsString(); + set => this.Set((int)HelpPluginSymbolFields.HelpNamespaceRef, value); + } + + public string ParentHelpNamespaceRef + { + get => this.Fields[(int)HelpPluginSymbolFields.ParentHelpNamespaceRef].AsString(); + set => this.Set((int)HelpPluginSymbolFields.ParentHelpNamespaceRef, value); + } + + public string HxTFileRef + { + get => this.Fields[(int)HelpPluginSymbolFields.HxTFileRef].AsString(); + set => this.Set((int)HelpPluginSymbolFields.HxTFileRef, value); + } + + public string HxAFileRef + { + get => this.Fields[(int)HelpPluginSymbolFields.HxAFileRef].AsString(); + set => this.Set((int)HelpPluginSymbolFields.HxAFileRef, value); + } + + public string ParentHxTFileRef + { + get => this.Fields[(int)HelpPluginSymbolFields.ParentHxTFileRef].AsString(); + set => this.Set((int)HelpPluginSymbolFields.ParentHxTFileRef, value); + } + } +} \ No newline at end of file diff --git a/src/ext/VisualStudio/wixext/Symbols/VSSymbolDefinitions.cs b/src/ext/VisualStudio/wixext/Symbols/VSSymbolDefinitions.cs new file mode 100644 index 00000000..cea6a2b6 --- /dev/null +++ b/src/ext/VisualStudio/wixext/Symbols/VSSymbolDefinitions.cs @@ -0,0 +1,59 @@ +// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information. + +namespace WixToolset.VisualStudio +{ + using System; + using WixToolset.Data; + + public enum VSSymbolDefinitionType + { + HelpFile, + HelpFileToNamespace, + HelpFilter, + HelpFilterToNamespace, + HelpNamespace, + HelpPlugin, + } + + public static partial class VSSymbolDefinitions + { + public static readonly Version Version = new Version("4.0.0"); + + public static IntermediateSymbolDefinition ByName(string name) + { + if (!Enum.TryParse(name, out VSSymbolDefinitionType type)) + { + return null; + } + + return ByType(type); + } + + public static IntermediateSymbolDefinition ByType(VSSymbolDefinitionType type) + { + switch (type) + { + case VSSymbolDefinitionType.HelpFile: + return VSSymbolDefinitions.HelpFile; + + case VSSymbolDefinitionType.HelpFileToNamespace: + return VSSymbolDefinitions.HelpFileToNamespace; + + case VSSymbolDefinitionType.HelpFilter: + return VSSymbolDefinitions.HelpFilter; + + case VSSymbolDefinitionType.HelpFilterToNamespace: + return VSSymbolDefinitions.HelpFilterToNamespace; + + case VSSymbolDefinitionType.HelpNamespace: + return VSSymbolDefinitions.HelpNamespace; + + case VSSymbolDefinitionType.HelpPlugin: + return VSSymbolDefinitions.HelpPlugin; + + default: + throw new ArgumentOutOfRangeException(nameof(type)); + } + } + } +} diff --git a/src/ext/VisualStudio/wixext/VSCompiler.cs b/src/ext/VisualStudio/wixext/VSCompiler.cs new file mode 100644 index 00000000..65f0f97d --- /dev/null +++ b/src/ext/VisualStudio/wixext/VSCompiler.cs @@ -0,0 +1,828 @@ +// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information. + +namespace WixToolset.VisualStudio +{ + using System; + using System.Collections.Generic; + using System.Globalization; + using System.Xml.Linq; + using WixToolset.Data; + using WixToolset.Data.Symbols; + using WixToolset.Data.WindowsInstaller; + using WixToolset.Extensibility; + using WixToolset.VisualStudio.Symbols; + + /// + /// The compiler for the WiX Toolset Visual Studio Extension. + /// + public sealed class VSCompiler : BaseCompilerExtension + { + internal const int MsidbCustomActionTypeExe = 0x00000002; // Target = command line args + internal const int MsidbCustomActionTypeProperty = 0x00000030; // Source = full path to executable + internal const int MsidbCustomActionTypeContinue = 0x00000040; // ignore action return status; continue running + internal const int MsidbCustomActionTypeRollback = 0x00000100; // in conjunction with InScript: queue in Rollback script + internal const int MsidbCustomActionTypeInScript = 0x00000400; // queue for execution within script + internal const int MsidbCustomActionTypeNoImpersonate = 0x00000800; // queue for not impersonating + + public override XNamespace Namespace => "http://wixtoolset.org/schemas/v4/wxs/vs"; + + public override void ParseElement(Intermediate intermediate, IntermediateSection section, XElement parentElement, XElement element, IDictionary context) + { + switch (parentElement.Name.LocalName) + { + case "Component": + switch (element.Name.LocalName) + { + case "VsixPackage": + this.ParseVsixPackageElement(intermediate, section, element, context["ComponentId"], null); + break; + default: + this.ParseHelper.UnexpectedElement(parentElement, element); + break; + } + break; + case "File": + switch (element.Name.LocalName) + { + case "HelpCollection": + this.ParseHelpCollectionElement(intermediate, section, element, context["FileId"]); + break; + case "HelpFile": + this.ParseHelpFileElement(intermediate, section, element, context["FileId"]); + break; + case "VsixPackage": + this.ParseVsixPackageElement(intermediate, section, element, context["ComponentId"], context["FileId"]); + break; + default: + this.ParseHelper.UnexpectedElement(parentElement, element); + break; + } + break; + case "Fragment": + case "Module": + case "Package": + switch (element.Name.LocalName) + { + case "HelpCollectionRef": + this.ParseHelpCollectionRefElement(intermediate, section, element); + break; + case "HelpFilter": + this.ParseHelpFilterElement(intermediate, section, element); + break; + default: + this.ParseHelper.UnexpectedElement(parentElement, element); + break; + } + break; + default: + this.ParseHelper.UnexpectedElement(parentElement, element); + break; + } + } + + private void ParseHelpCollectionRefElement(Intermediate intermediate, IntermediateSection section, XElement element) + { + var sourceLineNumbers = this.ParseHelper.GetSourceLineNumbers(element); + Identifier id = null; + + foreach (var attrib in element.Attributes()) + { + if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || this.Namespace == attrib.Name.Namespace) + { + switch (attrib.Name.LocalName) + { + case "Id": + id = this.ParseHelper.GetAttributeIdentifier(sourceLineNumbers, attrib); + this.ParseHelper.CreateSimpleReference(section, sourceLineNumbers, VSSymbolDefinitions.HelpNamespace, id.Id); + break; + default: + this.ParseHelper.UnexpectedAttribute(element, attrib); + break; + } + } + else + { + this.ParseHelper.ParseExtensionAttribute(this.Context.Extensions, intermediate, section, element, attrib); + } + } + + if (null == id) + { + this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, element.Name.LocalName, "Id")); + } + + foreach (var child in element.Elements()) + { + if (this.Namespace == child.Name.Namespace) + { + switch (child.Name.LocalName) + { + case "HelpFileRef": + this.ParseHelpFileRefElement(intermediate, section, child, id); + break; + default: + this.ParseHelper.UnexpectedElement(element, child); + break; + } + } + else + { + this.ParseHelper.ParseExtensionElement(this.Context.Extensions, intermediate, section, element, child); + } + } + } + + private void ParseHelpCollectionElement(Intermediate intermediate, IntermediateSection section, XElement element, string fileId) + { + var sourceLineNumbers = this.ParseHelper.GetSourceLineNumbers(element); + Identifier id = null; + string description = null; + string name = null; + var suppressCAs = YesNoType.No; + + foreach (var attrib in element.Attributes()) + { + if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || this.Namespace == attrib.Name.Namespace) + { + switch (attrib.Name.LocalName) + { + case "Id": + id = this.ParseHelper.GetAttributeIdentifier(sourceLineNumbers, attrib); + break; + case "Description": + description = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib); + break; + case "Name": + name = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib); + break; + case "SuppressCustomActions": + suppressCAs = this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib); + break; + default: + this.ParseHelper.UnexpectedAttribute(element, attrib); + break; + } + } + else + { + this.ParseHelper.ParseExtensionAttribute(this.Context.Extensions, intermediate, section, element, attrib); + } + } + + if (null == id) + { + id = this.ParseHelper.CreateIdentifier("vshc", fileId, description, name); + } + + if (null == description) + { + this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, element.Name.LocalName, "Description")); + } + + if (null == name) + { + this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, element.Name.LocalName, "Name")); + } + + foreach (var child in element.Elements()) + { + if (this.Namespace == child.Name.Namespace) + { + switch (child.Name.LocalName) + { + case "HelpFileRef": + this.ParseHelpFileRefElement(intermediate, section, child, id); + break; + case "HelpFilterRef": + this.ParseHelpFilterRefElement(intermediate, section, child, id); + break; + case "PlugCollectionInto": + this.ParsePlugCollectionIntoElement(intermediate, section, child, id); + break; + default: + this.ParseHelper.UnexpectedElement(element, child); + break; + } + } + else + { + this.ParseHelper.ParseExtensionElement(this.Context.Extensions, intermediate, section, element, child); + } + } + + if (!this.Messaging.EncounteredError) + { + section.AddSymbol(new HelpNamespaceSymbol(sourceLineNumbers, id) + { + NamespaceName = name, + CollectionFileRef = fileId, + Description = description, + }); + + if (YesNoType.No == suppressCAs) + { + this.AddReferenceToRegisterMicrosoftHelp(section, sourceLineNumbers); + } + } + } + + private void ParseHelpFileElement(Intermediate intermediate, IntermediateSection section, XElement element, string fileId) + { + var sourceLineNumbers = this.ParseHelper.GetSourceLineNumbers(element); + Identifier id = null; + string name = null; + var language = CompilerConstants.IntegerNotSet; + string hxi = null; + string hxq = null; + string hxr = null; + string samples = null; + var suppressCAs = YesNoType.No; + + foreach (var attrib in element.Attributes()) + { + if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || this.Namespace == attrib.Name.Namespace) + { + switch (attrib.Name.LocalName) + { + case "Id": + id = this.ParseHelper.GetAttributeIdentifier(sourceLineNumbers, attrib); + break; + case "AttributeIndex": + hxr = this.ParseHelper.GetAttributeIdentifierValue(sourceLineNumbers, attrib); + this.ParseHelper.CreateSimpleReference(section, sourceLineNumbers, SymbolDefinitions.File, hxr); + break; + case "Index": + hxi = this.ParseHelper.GetAttributeIdentifierValue(sourceLineNumbers, attrib); + this.ParseHelper.CreateSimpleReference(section, sourceLineNumbers, SymbolDefinitions.File, hxi); + break; + case "Language": + language = this.ParseHelper.GetAttributeIntegerValue(sourceLineNumbers, attrib, 0, short.MaxValue); + break; + case "Name": + name = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib); + break; + case "SampleLocation": + samples = this.ParseHelper.GetAttributeIdentifierValue(sourceLineNumbers, attrib); + this.ParseHelper.CreateSimpleReference(section, sourceLineNumbers, SymbolDefinitions.File, samples); + break; + case "Search": + hxq = this.ParseHelper.GetAttributeIdentifierValue(sourceLineNumbers, attrib); + this.ParseHelper.CreateSimpleReference(section, sourceLineNumbers, SymbolDefinitions.File, hxq); + break; + case "SuppressCustomActions": + suppressCAs = this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib); + break; + default: + this.ParseHelper.UnexpectedAttribute(element, attrib); + break; + } + } + else + { + this.ParseHelper.ParseExtensionAttribute(this.Context.Extensions, intermediate, section, element, attrib); + } + } + + if (null == id) + { + id = this.ParseHelper.CreateIdentifier("vshf", fileId, name, language.ToString(CultureInfo.InvariantCulture.NumberFormat)); + } + + if (null == name) + { + this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, element.Name.LocalName, "Name")); + } + + // Uninstall will always fail silently, leaving file registered, if Language is not set + if (CompilerConstants.IntegerNotSet == language) + { + this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, element.Name.LocalName, "Language")); + } + + this.ParseHelper.ParseForExtensionElements(this.Context.Extensions, intermediate, section, element); + + if (!this.Messaging.EncounteredError) + { + section.AddSymbol(new HelpFileSymbol(sourceLineNumbers, id) + { + HelpFileName = name, + LangID = language, + HxSFileRef = fileId, + HxIFileRef = hxi, + HxQFileRef = hxq, + HxRFileRef = hxr, + SamplesFileRef = samples, + }); + + if (YesNoType.No == suppressCAs) + { + this.AddReferenceToRegisterMicrosoftHelp(section, sourceLineNumbers); + } + } + } + + private void ParseHelpFileRefElement(Intermediate intermediate, IntermediateSection section, XElement element, Identifier collectionId) + { + var sourceLineNumbers = this.ParseHelper.GetSourceLineNumbers(element); + Identifier id = null; + + foreach (var attrib in element.Attributes()) + { + if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || this.Namespace == attrib.Name.Namespace) + { + switch (attrib.Name.LocalName) + { + case "Id": + id = this.ParseHelper.GetAttributeIdentifier(sourceLineNumbers, attrib); + this.ParseHelper.CreateSimpleReference(section, sourceLineNumbers, VSSymbolDefinitions.HelpFile, id.Id); + break; + default: + this.ParseHelper.UnexpectedAttribute(element, attrib); + break; + } + } + else + { + this.ParseHelper.ParseExtensionAttribute(this.Context.Extensions, intermediate, section, element, attrib); + } + } + + if (null == id) + { + this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, element.Name.LocalName, "Id")); + } + + this.ParseHelper.ParseForExtensionElements(this.Context.Extensions, intermediate, section, element); + + if (!this.Messaging.EncounteredError) + { + section.AddSymbol(new HelpFileToNamespaceSymbol(sourceLineNumbers, id) + { + HelpFileRef = id.Id, + HelpNamespaceRef = collectionId.Id, + }); + } + } + + private void ParseHelpFilterElement(Intermediate intermediate, IntermediateSection section, XElement element) + { + var sourceLineNumbers = this.ParseHelper.GetSourceLineNumbers(element); + Identifier id = null; + string filterDefinition = null; + string name = null; + var suppressCAs = YesNoType.No; + + foreach (var attrib in element.Attributes()) + { + if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || this.Namespace == attrib.Name.Namespace) + { + switch (attrib.Name.LocalName) + { + case "Id": + id = this.ParseHelper.GetAttributeIdentifier(sourceLineNumbers, attrib); + break; + case "FilterDefinition": + filterDefinition = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib); + break; + case "Name": + name = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib); + break; + case "SuppressCustomActions": + suppressCAs = this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib); + break; + default: + this.ParseHelper.UnexpectedAttribute(element, attrib); + break; + } + } + else + { + this.ParseHelper.ParseExtensionAttribute(this.Context.Extensions, intermediate, section, element, attrib); + } + } + + if (null == id) + { + id = this.ParseHelper.CreateIdentifier("hfl", name, filterDefinition); + } + + if (null == name) + { + this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, element.Name.LocalName, "Name")); + } + + this.ParseHelper.ParseForExtensionElements(this.Context.Extensions, intermediate, section, element); + + if (!this.Messaging.EncounteredError) + { + section.AddSymbol(new HelpFilterSymbol(sourceLineNumbers, id) + { + Description = name, + QueryString = filterDefinition, + }); + + if (YesNoType.No == suppressCAs) + { + this.AddReferenceToRegisterMicrosoftHelp(section, sourceLineNumbers); + } + } + } + + private void ParseHelpFilterRefElement(Intermediate intermediate, IntermediateSection section, XElement element, Identifier collectionId) + { + var sourceLineNumbers = this.ParseHelper.GetSourceLineNumbers(element); + Identifier id = null; + + foreach (var attrib in element.Attributes()) + { + if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || this.Namespace == attrib.Name.Namespace) + { + switch (attrib.Name.LocalName) + { + case "Id": + id = this.ParseHelper.GetAttributeIdentifier(sourceLineNumbers, attrib); + this.ParseHelper.CreateSimpleReference(section, sourceLineNumbers, VSSymbolDefinitions.HelpFilter, id.Id); + break; + default: + this.ParseHelper.UnexpectedAttribute(element, attrib); + break; + } + } + else + { + this.ParseHelper.ParseExtensionAttribute(this.Context.Extensions, intermediate, section, element, attrib); + } + } + + if (null == id) + { + this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, element.Name.LocalName, "Id")); + } + + this.ParseHelper.ParseForExtensionElements(this.Context.Extensions, intermediate, section, element); + + if (!this.Messaging.EncounteredError) + { + section.AddSymbol(new HelpFilterToNamespaceSymbol(sourceLineNumbers, id) + { + HelpFilterRef = id.Id, + HelpNamespaceRef = collectionId.Id, + }); + } + } + + private void ParsePlugCollectionIntoElement(Intermediate intermediate, IntermediateSection section, XElement element, Identifier parentId) + { + var sourceLineNumbers = this.ParseHelper.GetSourceLineNumbers(element); + string hxa = null; + string hxt = null; + string hxtParent = null; + string namespaceParent = null; + string feature = null; + var suppressExternalNamespaces = YesNoType.No; + + foreach (var attrib in element.Attributes()) + { + if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || this.Namespace == attrib.Name.Namespace) + { + switch (attrib.Name.LocalName) + { + case "Attributes": + hxa = this.ParseHelper.GetAttributeIdentifierValue(sourceLineNumbers, attrib); + break; + case "TableOfContents": + hxt = this.ParseHelper.GetAttributeIdentifierValue(sourceLineNumbers, attrib); + break; + case "TargetCollection": + namespaceParent = this.ParseHelper.GetAttributeIdentifierValue(sourceLineNumbers, attrib); + break; + case "TargetTableOfContents": + hxtParent = this.ParseHelper.GetAttributeIdentifierValue(sourceLineNumbers, attrib); + break; + case "TargetFeature": + feature = this.ParseHelper.GetAttributeIdentifierValue(sourceLineNumbers, attrib); + break; + case "SuppressExternalNamespaces": + suppressExternalNamespaces = this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib); + break; + default: + this.ParseHelper.UnexpectedAttribute(element, attrib); + break; + } + } + else + { + this.ParseHelper.ParseExtensionAttribute(this.Context.Extensions, intermediate, section, element, attrib); + } + } + + var pluginVS05 = namespaceParent.Equals("MS_VSIPCC_v80", StringComparison.Ordinal); + var pluginVS08 = namespaceParent.Equals("MS.VSIPCC.v90", StringComparison.Ordinal); + + if (null == namespaceParent) + { + this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, element.Name.LocalName, "TargetCollection")); + } + + if (null == feature && (pluginVS05 || pluginVS08) && YesNoType.No == suppressExternalNamespaces) + { + this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, element.Name.LocalName, "TargetFeature")); + } + + this.ParseHelper.ParseForExtensionElements(this.Context.Extensions, intermediate, section, element); + + if (!this.Messaging.EncounteredError) + { + section.AddSymbol(new HelpPluginSymbol(sourceLineNumbers, parentId) + { + HelpNamespaceRef = parentId.Id, + ParentHelpNamespaceRef = namespaceParent, + HxTFileRef = hxt, + HxAFileRef = hxa, + ParentHxTFileRef = hxtParent, + }); + + if (pluginVS05) + { + if (YesNoType.No == suppressExternalNamespaces) + { + // Bring in the help 2 base namespace components for VS 2005 + this.ParseHelper.CreateComplexReference(section, sourceLineNumbers, ComplexReferenceParentType.Feature, feature, String.Empty, + ComplexReferenceChildType.ComponentGroup, "Help2_VS2005_Namespace_Components", false); + // Reference CustomAction since nothing will happen without it + this.ParseHelper.CreateSimpleReference(section, sourceLineNumbers, SymbolDefinitions.CustomAction, "CA_HxMerge_VSIPCC_VSCC"); + } + } + else if (pluginVS08) + { + if (YesNoType.No == suppressExternalNamespaces) + { + // Bring in the help 2 base namespace components for VS 2008 + this.ParseHelper.CreateComplexReference(section, sourceLineNumbers, ComplexReferenceParentType.Feature, feature, String.Empty, + ComplexReferenceChildType.ComponentGroup, "Help2_VS2008_Namespace_Components", false); + // Reference CustomAction since nothing will happen without it + this.ParseHelper.CreateSimpleReference(section, sourceLineNumbers, SymbolDefinitions.CustomAction, "CA_ScheduleExtHelpPlugin_VSCC_VSIPCC"); + } + } + else + { + // Reference the parent namespace to enforce the foreign key relationship + this.ParseHelper.CreateSimpleReference(section, sourceLineNumbers, VSSymbolDefinitions.HelpNamespace, namespaceParent); + } + } + } + + private void ParseVsixPackageElement(Intermediate intermediate, IntermediateSection section, XElement element, string componentId, string fileId) + { + var sourceLineNumbers = this.ParseHelper.GetSourceLineNumbers(element); + var propertyId = "VS_VSIX_INSTALLER_PATH"; + string packageId = null; + var permanent = YesNoType.NotSet; + string target = null; + string targetVersion = null; + var vital = YesNoType.NotSet; + + foreach (var attrib in element.Attributes()) + { + if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || this.Namespace == attrib.Name.Namespace) + { + switch (attrib.Name.LocalName) + { + case "File": + if (String.IsNullOrEmpty(fileId)) + { + fileId = this.ParseHelper.GetAttributeIdentifierValue(sourceLineNumbers, attrib); + } + else + { + this.Messaging.Write(ErrorMessages.IllegalAttributeWhenNested(sourceLineNumbers, element.Name.LocalName, "File", "File")); + } + break; + case "PackageId": + packageId = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib); + break; + case "Permanent": + permanent = this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib); + break; + case "Target": + target = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib); + switch (target.ToLowerInvariant()) + { + case "integrated": + case "integratedshell": + target = "IntegratedShell"; + break; + case "professional": + target = "Pro"; + break; + case "premium": + target = "Premium"; + break; + case "ultimate": + target = "Ultimate"; + break; + case "vbexpress": + target = "VBExpress"; + break; + case "vcexpress": + target = "VCExpress"; + break; + case "vcsexpress": + target = "VCSExpress"; + break; + case "vwdexpress": + target = "VWDExpress"; + break; + } + break; + case "TargetVersion": + targetVersion = this.ParseHelper.GetAttributeVersionValue(sourceLineNumbers, attrib); + break; + case "Vital": + vital = this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib); + break; + case "VsixInstallerPathProperty": + propertyId = this.ParseHelper.GetAttributeIdentifierValue(sourceLineNumbers, attrib); + break; + default: + this.ParseHelper.UnexpectedAttribute(element, attrib); + break; + } + } + else + { + this.ParseHelper.ParseExtensionAttribute(this.Context.Extensions, intermediate, section, element, attrib); + } + } + + if (String.IsNullOrEmpty(fileId)) + { + this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, element.Name.LocalName, "File")); + } + + if (String.IsNullOrEmpty(packageId)) + { + this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, element.Name.LocalName, "PackageId")); + } + + if (!String.IsNullOrEmpty(target) && String.IsNullOrEmpty(targetVersion)) + { + this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, element.Name.LocalName, "TargetVersion", "Target")); + } + else if (String.IsNullOrEmpty(target) && !String.IsNullOrEmpty(targetVersion)) + { + this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, element.Name.LocalName, "Target", "TargetVersion")); + } + + this.ParseHelper.ParseForExtensionElements(this.Context.Extensions, intermediate, section, element); + + if (!this.Messaging.EncounteredError) + { + // Ensure there is a reference to the AppSearch Property that will find the VsixInstaller.exe. + this.ParseHelper.CreateSimpleReference(section, sourceLineNumbers, SymbolDefinitions.Property, propertyId); + + // Ensure there is a reference to the package file (even if we are a child under it). + this.ParseHelper.CreateSimpleReference(section, sourceLineNumbers, SymbolDefinitions.File, fileId); + + var cmdlinePrefix = "/q "; + + if (!String.IsNullOrEmpty(target)) + { + cmdlinePrefix = String.Format("{0} /skuName:{1} /skuVersion:{2}", cmdlinePrefix, target, targetVersion); + } + + var installAfter = "WriteRegistryValues"; // by default, come after the registry key registration. + + var installNamePerUser = this.ParseHelper.CreateIdentifier("viu", componentId, fileId, "per-user", target, targetVersion); + var installNamePerMachine = this.ParseHelper.CreateIdentifier("vim", componentId, fileId, "per-machine", target, targetVersion); + var installCmdLinePerUser = String.Format("{0} \"[#{1}]\"", cmdlinePrefix, fileId); + var installCmdLinePerMachine = String.Concat(installCmdLinePerUser, " /admin"); + var installConditionPerUser = String.Format("NOT ALLUSERS AND ${0}=3", componentId); // only execute if the Component being installed. + var installConditionPerMachine = String.Format("ALLUSERS AND ${0}=3", componentId); // only execute if the Component being installed. + var installPerUserCA = new CustomActionSymbol(sourceLineNumbers, installNamePerUser) + { + ExecutionType = CustomActionExecutionType.Deferred, + Impersonate = true, + }; + var installPerMachineCA = new CustomActionSymbol(sourceLineNumbers, installNamePerMachine) + { + ExecutionType = CustomActionExecutionType.Deferred, + Impersonate = false, + }; + + // If the package is not vital, mark the install action as continue. + if (vital == YesNoType.No) + { + installPerUserCA.IgnoreResult = true; + installPerMachineCA.IgnoreResult = true; + } + else // the package is vital so ensure there is a rollback action scheduled. + { + var rollbackNamePerUser = this.ParseHelper.CreateIdentifier("vru", componentId, fileId, "per-user", target, targetVersion); + var rollbackNamePerMachine = this.ParseHelper.CreateIdentifier("vrm", componentId, fileId, "per-machine", target, targetVersion); + var rollbackCmdLinePerUser = String.Concat(cmdlinePrefix, " /u:\"", packageId, "\""); + var rollbackCmdLinePerMachine = String.Concat(rollbackCmdLinePerUser, " /admin"); + var rollbackConditionPerUser = String.Format("NOT ALLUSERS AND NOT Installed AND ${0}=2 AND ?{0}>2", componentId); // NOT Installed && Component being installed but not installed already. + var rollbackConditionPerMachine = String.Format("ALLUSERS AND NOT Installed AND ${0}=2 AND ?{0}>2", componentId); // NOT Installed && Component being installed but not installed already. + var rollbackPerUserCA = new CustomActionSymbol(sourceLineNumbers, rollbackNamePerUser) + { + ExecutionType = CustomActionExecutionType.Rollback, + IgnoreResult = true, + Impersonate = true, + }; + var rollbackPerMachineCA = new CustomActionSymbol(sourceLineNumbers, rollbackNamePerMachine) + { + ExecutionType = CustomActionExecutionType.Rollback, + IgnoreResult = true, + Impersonate = false, + }; + + this.SchedulePropertyExeAction(section, sourceLineNumbers, rollbackNamePerUser, propertyId, rollbackCmdLinePerUser, rollbackPerUserCA, rollbackConditionPerUser, null, installAfter); + this.SchedulePropertyExeAction(section, sourceLineNumbers, rollbackNamePerMachine, propertyId, rollbackCmdLinePerMachine, rollbackPerMachineCA, rollbackConditionPerMachine, null, rollbackNamePerUser.Id); + + installAfter = rollbackNamePerMachine.Id; + } + + this.SchedulePropertyExeAction(section, sourceLineNumbers, installNamePerUser, propertyId, installCmdLinePerUser, installPerUserCA, installConditionPerUser, null, installAfter); + this.SchedulePropertyExeAction(section, sourceLineNumbers, installNamePerMachine, propertyId, installCmdLinePerMachine, installPerMachineCA, installConditionPerMachine, null, installNamePerUser.Id); + + // If not permanent, schedule the uninstall custom action. + if (permanent != YesNoType.Yes) + { + var uninstallNamePerUser = this.ParseHelper.CreateIdentifier("vuu", componentId, fileId, "per-user", target ?? String.Empty, targetVersion ?? String.Empty); + var uninstallNamePerMachine = this.ParseHelper.CreateIdentifier("vum", componentId, fileId, "per-machine", target ?? String.Empty, targetVersion ?? String.Empty); + var uninstallCmdLinePerUser = String.Concat(cmdlinePrefix, " /u:\"", packageId, "\""); + var uninstallCmdLinePerMachine = String.Concat(uninstallCmdLinePerUser, " /admin"); + var uninstallConditionPerUser = String.Format("NOT ALLUSERS AND ${0}=2 AND ?{0}>2", componentId); // Only execute if component is being uninstalled. + var uninstallConditionPerMachine = String.Format("ALLUSERS AND ${0}=2 AND ?{0}>2", componentId); // Only execute if component is being uninstalled. + var uninstallPerUserCA = new CustomActionSymbol(sourceLineNumbers, uninstallNamePerUser) + { + ExecutionType = CustomActionExecutionType.Deferred, + IgnoreResult = true, + Impersonate = true, + }; + var uninstallPerMachineCA = new CustomActionSymbol(sourceLineNumbers, uninstallNamePerMachine) + { + ExecutionType = CustomActionExecutionType.Deferred, + IgnoreResult = true, + Impersonate = false, + }; + + this.SchedulePropertyExeAction(section, sourceLineNumbers, uninstallNamePerUser, propertyId, uninstallCmdLinePerUser, uninstallPerUserCA, uninstallConditionPerUser, "InstallFinalize", null); + this.SchedulePropertyExeAction(section, sourceLineNumbers, uninstallNamePerMachine, propertyId, uninstallCmdLinePerMachine, uninstallPerMachineCA, uninstallConditionPerMachine, "InstallFinalize", null); + } + } + } + + private void SchedulePropertyExeAction(IntermediateSection section, SourceLineNumber sourceLineNumbers, Identifier name, string source, string cmdline, CustomActionSymbol caTemplate, string condition, string beforeAction, string afterAction) + { + const SequenceTable sequence = SequenceTable.InstallExecuteSequence; + + caTemplate.SourceType = CustomActionSourceType.Property; + caTemplate.Source = source; + caTemplate.TargetType = CustomActionTargetType.Exe; + caTemplate.Target = cmdline; + section.AddSymbol(caTemplate); + + section.AddSymbol(new WixActionSymbol(sourceLineNumbers, new Identifier(name.Access, sequence, name.Id)) + { + SequenceTable = SequenceTable.InstallExecuteSequence, + Action = name.Id, + Condition = condition, + // no explicit sequence + Before = beforeAction, + After = afterAction, + Overridable = false, + }); + + if (null != beforeAction) + { + if (WindowsInstallerStandard.IsStandardAction(beforeAction)) + { + this.ParseHelper.CreateSimpleReference(section, sourceLineNumbers, SymbolDefinitions.WixAction, sequence.ToString(), beforeAction); + } + else + { + this.ParseHelper.CreateSimpleReference(section, sourceLineNumbers, SymbolDefinitions.CustomAction, beforeAction); + } + } + + if (null != afterAction) + { + if (WindowsInstallerStandard.IsStandardAction(afterAction)) + { + this.ParseHelper.CreateSimpleReference(section, sourceLineNumbers, SymbolDefinitions.WixAction, sequence.ToString(), afterAction); + } + else + { + this.ParseHelper.CreateSimpleReference(section, sourceLineNumbers, SymbolDefinitions.CustomAction, afterAction); + } + } + } + + private void AddReferenceToRegisterMicrosoftHelp(IntermediateSection section, SourceLineNumber sourceLineNumbers) + { + this.ParseHelper.CreateSimpleReference(section, sourceLineNumbers, SymbolDefinitions.CustomAction, "CA_RegisterMicrosoftHelp.3643236F_FC70_11D3_A536_0090278A1BB8"); + } + } +} diff --git a/src/ext/VisualStudio/wixext/VSDecompiler.cs b/src/ext/VisualStudio/wixext/VSDecompiler.cs new file mode 100644 index 00000000..08dc364a --- /dev/null +++ b/src/ext/VisualStudio/wixext/VSDecompiler.cs @@ -0,0 +1,298 @@ +// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information. + +namespace WixToolset.VisualStudio +{ +#if TODO_CONSIDER_DECOMPILER + using System; + using System.Collections; + using System.Diagnostics; + using System.Globalization; + using WixToolset.Data; + using WixToolset.Extensibility; + using VS = WixToolset.Extensions.Serialize.VS; + using Wix = WixToolset.Data.Serialize; + + /// + /// The decompiler for the WiX Toolset Visual Studio Extension. + /// + public sealed class VSDecompiler : DecompilerExtension + { + /// + /// Creates a decompiler for VS Extension. + /// + public VSDecompiler() + { + this.TableDefinitions = VSExtensionData.GetExtensionTableDefinitions(); + } + + /// + /// Get the extensions library to be removed. + /// + /// Table definitions for library. + /// Library to remove from decompiled output. + public override Library GetLibraryToRemove(TableDefinitionCollection tableDefinitions) + { + return VSExtensionData.GetExtensionLibrary(tableDefinitions); + } + + /// + /// Decompiles an extension table. + /// + /// The table to decompile. + public override void DecompileTable(Table table) + { + switch (table.Name) + { + case "HelpFile": + this.DecompileHelpFileTable(table); + break; + case "HelpFileToNamespace": + this.DecompileHelpFileToNamespaceTable(table); + break; + case "HelpFilter": + this.DecompileHelpFilterTable(table); + break; + case "HelpFilterToNamespace": + this.DecompileHelpFilterToNamespaceTable(table); + break; + case "HelpNamespace": + this.DecompileHelpNamespaceTable(table); + break; + case "HelpPlugin": + this.DecompileHelpPluginTable(table); + break; + default: + base.DecompileTable(table); + break; + } + } + + /// + /// Decompile the HelpFile table. + /// + /// The table to decompile. + private void DecompileHelpFileTable(Table table) + { + foreach (Row row in table.Rows) + { + VS.HelpFile helpFile = new VS.HelpFile(); + + helpFile.Id = (string)row[0]; + + helpFile.Name = (string)row[1]; + + if (null != row[2]) + { + helpFile.Language = (int)row[2]; + } + + if (null != row[4]) + { + helpFile.Index = (string)row[4]; + } + + if (null != row[5]) + { + helpFile.Search = (string)row[5]; + } + + if (null != row[6]) + { + helpFile.AttributeIndex = (string)row[6]; + } + + if (null != row[7]) + { + helpFile.SampleLocation = (string)row[7]; + } + + if (this.Core.RootElement is Wix.Module) + { + helpFile.SuppressCustomActions = VS.YesNoType.yes; + } + + Wix.File file = (Wix.File)this.Core.GetIndexedElement("File", (string)row[3]); + if (null != file) + { + file.AddChild(helpFile); + } + else + { + this.Core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "File_HxS", (string)row[3], "File")); + } + } + } + + /// + /// Decompile the HelpFileToNamespace table. + /// + /// The table to decompile. + private void DecompileHelpFileToNamespaceTable(Table table) + { + foreach (Row row in table.Rows) + { + VS.HelpFileRef helpFileRef = new VS.HelpFileRef(); + + helpFileRef.Id = (string)row[0]; + + VS.HelpCollection helpCollection = (VS.HelpCollection)this.Core.GetIndexedElement("HelpNamespace", (string)row[1]); + if (null != helpCollection) + { + helpCollection.AddChild(helpFileRef); + } + else + { + this.Core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "HelpNamespace_", (string)row[1], "HelpNamespace")); + } + } + } + + /// + /// Decompile the HelpFilter table. + /// + /// The table to decompile. + private void DecompileHelpFilterTable(Table table) + { + foreach (Row row in table.Rows) + { + VS.HelpFilter helpFilter = new VS.HelpFilter(); + + helpFilter.Id = (string)row[0]; + + helpFilter.Name = (string)row[1]; + + if (null != row[2]) + { + helpFilter.FilterDefinition = (string)row[2]; + } + + if (this.Core.RootElement is Wix.Module) + { + helpFilter.SuppressCustomActions = VS.YesNoType.yes; + } + + this.Core.RootElement.AddChild(helpFilter); + } + } + + /// + /// Decompile the HelpFilterToNamespace table. + /// + /// The table to decompile. + private void DecompileHelpFilterToNamespaceTable(Table table) + { + foreach (Row row in table.Rows) + { + VS.HelpFilterRef helpFilterRef = new VS.HelpFilterRef(); + + helpFilterRef.Id = (string)row[0]; + + VS.HelpCollection helpCollection = (VS.HelpCollection)this.Core.GetIndexedElement("HelpNamespace", (string)row[1]); + if (null != helpCollection) + { + helpCollection.AddChild(helpFilterRef); + } + else + { + this.Core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "HelpNamespace_", (string)row[1], "HelpNamespace")); + } + } + } + + /// + /// Decompile the HelpNamespace table. + /// + /// The table to decompile. + private void DecompileHelpNamespaceTable(Table table) + { + foreach (Row row in table.Rows) + { + VS.HelpCollection helpCollection = new VS.HelpCollection(); + + helpCollection.Id = (string)row[0]; + + helpCollection.Name = (string)row[1]; + + if (null != row[3]) + { + helpCollection.Description = (string)row[3]; + } + + if (this.Core.RootElement is Wix.Module) + { + helpCollection.SuppressCustomActions = VS.YesNoType.yes; + } + + Wix.File file = (Wix.File)this.Core.GetIndexedElement("File", (string)row[2]); + if (null != file) + { + file.AddChild(helpCollection); + } + else if (0 != String.Compare(helpCollection.Id, "MS_VSIPCC_v80", StringComparison.Ordinal) && + 0 != String.Compare(helpCollection.Id, "MS.VSIPCC.v90", StringComparison.Ordinal)) + { + this.Core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "File_Collection", (string)row[2], "File")); + } + this.Core.IndexElement(row, helpCollection); + } + } + + /// + /// Decompile the HelpPlugin table. + /// + /// The table to decompile. + private void DecompileHelpPluginTable(Table table) + { + foreach (Row row in table.Rows) + { + VS.PlugCollectionInto plugCollectionInto = new VS.PlugCollectionInto(); + + plugCollectionInto.TargetCollection = (string)row[1]; + + if (null != row[2]) + { + plugCollectionInto.TableOfContents = (string)row[2]; + } + + if (null != row[3]) + { + plugCollectionInto.Attributes = (string)row[3]; + } + + if (null != row[4]) + { + plugCollectionInto.TargetTableOfContents = (string)row[4]; + } + + if (this.Core.RootElement is Wix.Module) + { + plugCollectionInto.SuppressExternalNamespaces = VS.YesNoType.yes; + } + + //we cannot do this work because we cannot get the FeatureComponent table + //plugCollectionInto.TargetFeature = DecompileHelpComponents(); + + VS.HelpCollection helpCollection = (VS.HelpCollection)this.Core.GetIndexedElement("HelpNamespace", (string)row[0]); + if (null != helpCollection) + { + helpCollection.AddChild(plugCollectionInto); + } + else + { + this.Core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "HelpNamespace_", (string)row[0], "HelpNamespace")); + } + } + } + //private string DecompileHelpComponents() + //{ + // throw new NotImplementedException(); + // //Find both known compontents from FeatureComponents table and build feature list + + // //remove components from FeatureComponents + + // //return a space delimited list of features that mapped to our help components + // return String.Empty; + //} + } +#endif +} diff --git a/src/ext/VisualStudio/wixext/VSExtensionData.cs b/src/ext/VisualStudio/wixext/VSExtensionData.cs new file mode 100644 index 00000000..51199d2c --- /dev/null +++ b/src/ext/VisualStudio/wixext/VSExtensionData.cs @@ -0,0 +1,27 @@ +// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information. + +namespace WixToolset.VisualStudio +{ + using WixToolset.Data; + using WixToolset.Extensibility; + + public sealed class VSExtensionData : BaseExtensionData + { + /// + /// Gets the default culture. + /// + /// The default culture. + public override string DefaultCulture => "en-US"; + + public override bool TryGetSymbolDefinitionByName(string name, out IntermediateSymbolDefinition symbolDefinition) + { + symbolDefinition = VSSymbolDefinitions.ByName(name); + return symbolDefinition != null; + } + + public override Intermediate GetLibrary(ISymbolDefinitionCreator symbolDefinitions) + { + return Intermediate.Load(typeof(VSExtensionData).Assembly, "WixToolset.VisualStudio.vs.wixlib", symbolDefinitions); + } + } +} diff --git a/src/ext/VisualStudio/wixext/VSExtensionFactory.cs b/src/ext/VisualStudio/wixext/VSExtensionFactory.cs new file mode 100644 index 00000000..c6e0cc31 --- /dev/null +++ b/src/ext/VisualStudio/wixext/VSExtensionFactory.cs @@ -0,0 +1,18 @@ +// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information. + +namespace WixToolset.VisualStudio +{ + using System; + using System.Collections.Generic; + using WixToolset.Extensibility; + + public class VSExtensionFactory : BaseExtensionFactory + { + protected override IReadOnlyCollection ExtensionTypes => new[] + { + typeof(VSCompiler), + typeof(VSExtensionData), + typeof(VSWindowsInstallerBackendBinderExtension), + }; + } +} diff --git a/src/ext/VisualStudio/wixext/VSTableDefinitions.cs b/src/ext/VisualStudio/wixext/VSTableDefinitions.cs new file mode 100644 index 00000000..0c3ca907 --- /dev/null +++ b/src/ext/VisualStudio/wixext/VSTableDefinitions.cs @@ -0,0 +1,97 @@ +// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information. + +namespace WixToolset.VisualStudio +{ + using WixToolset.Data.WindowsInstaller; + + public static class VSTableDefinitions + { + public static readonly TableDefinition HelpFile = new TableDefinition( + "HelpFile", + VSSymbolDefinitions.HelpFile, + new[] + { + new ColumnDefinition("HelpFileKey", ColumnType.String, 72, primaryKey: true, nullable: false, ColumnCategory.Identifier, description: "Primary Key for HelpFile Table (required).", modularizeType: ColumnModularizeType.Column), + new ColumnDefinition("HelpFileName", ColumnType.String, 72, primaryKey: false, nullable: false, ColumnCategory.Text, description: "Internal Microsoft Help ID for this HelpFile (required)."), + new ColumnDefinition("LangID", ColumnType.Number, 2, primaryKey: false, nullable: true, ColumnCategory.Language, description: "Language ID for content file (optional)."), + new ColumnDefinition("File_HxS", ColumnType.String, 72, primaryKey: false, nullable: false, ColumnCategory.Identifier, keyTable: "File", keyColumn: 1, description: "Key for HxS (Title) file (required).", modularizeType: ColumnModularizeType.Column), + new ColumnDefinition("File_HxI", ColumnType.String, 72, primaryKey: false, nullable: true, ColumnCategory.Identifier, keyTable: "File", keyColumn: 1, description: "Key for HxI (Index) file (optional).", modularizeType: ColumnModularizeType.Column), + new ColumnDefinition("File_HxQ", ColumnType.String, 72, primaryKey: false, nullable: true, ColumnCategory.Identifier, keyTable: "File", keyColumn: 1, description: "Key for HxQ (Query) file (optional).", modularizeType: ColumnModularizeType.Column), + new ColumnDefinition("File_HxR", ColumnType.String, 72, primaryKey: false, nullable: true, ColumnCategory.Identifier, keyTable: "File", keyColumn: 1, description: "Key for HxR (Attributes) file (optional).", modularizeType: ColumnModularizeType.Column), + new ColumnDefinition("File_Samples", ColumnType.String, 72, primaryKey: false, nullable: true, ColumnCategory.Identifier, keyTable: "File", keyColumn: 1, description: "Key for a file that is in the 'root' of the samples directory for this HelpFile (optional).", modularizeType: ColumnModularizeType.Column), + }, + symbolIdIsPrimaryKey: true + ); + + public static readonly TableDefinition HelpFileToNamespace = new TableDefinition( + "HelpFileToNamespace", + VSSymbolDefinitions.HelpFileToNamespace, + new[] + { + new ColumnDefinition("HelpFile_", ColumnType.String, 72, primaryKey: true, nullable: false, ColumnCategory.Identifier, keyTable: "HelpFile", keyColumn: 1, description: "Foreign key into HelpFile table (required).", modularizeType: ColumnModularizeType.Column), + new ColumnDefinition("HelpNamespace_", ColumnType.String, 72, primaryKey: true, nullable: false, ColumnCategory.Identifier, keyTable: "HelpNamespace", keyColumn: 1, description: "Foreign key into HelpNamespace table (required)."), + }, + symbolIdIsPrimaryKey: false + ); + + public static readonly TableDefinition HelpFilter = new TableDefinition( + "HelpFilter", + VSSymbolDefinitions.HelpFilter, + new[] + { + new ColumnDefinition("FilterKey", ColumnType.String, 72, primaryKey: true, nullable: false, ColumnCategory.Identifier, description: "Primary Key for HelpFilter (required).", modularizeType: ColumnModularizeType.Column), + new ColumnDefinition("Description", ColumnType.Localized, 0, primaryKey: false, nullable: false, ColumnCategory.Text, description: "Friendly name for Filter (required)."), + new ColumnDefinition("QueryString", ColumnType.String, 0, primaryKey: false, nullable: true, ColumnCategory.Text, description: "Query String for Help Filter (optional)."), + }, + symbolIdIsPrimaryKey: true + ); + + public static readonly TableDefinition HelpFilterToNamespace = new TableDefinition( + "HelpFilterToNamespace", + VSSymbolDefinitions.HelpFilterToNamespace, + new[] + { + new ColumnDefinition("HelpFilter_", ColumnType.String, 72, primaryKey: true, nullable: false, ColumnCategory.Identifier, keyTable: "HelpFilter", keyColumn: 1, description: "Foreign key into HelpFilter table (required).", modularizeType: ColumnModularizeType.Column), + new ColumnDefinition("HelpNamespace_", ColumnType.String, 72, primaryKey: true, nullable: false, ColumnCategory.Identifier, keyTable: "HelpNamespace", keyColumn: 1, description: "Foreign key into HelpNamespace table (required)."), + }, + symbolIdIsPrimaryKey: false + ); + + public static readonly TableDefinition HelpNamespace = new TableDefinition( + "HelpNamespace", + VSSymbolDefinitions.HelpNamespace, + new[] + { + new ColumnDefinition("NamespaceKey", ColumnType.String, 72, primaryKey: true, nullable: false, ColumnCategory.Identifier, description: "Primary Key for HelpNamespace (required)."), + new ColumnDefinition("NamespaceName", ColumnType.String, 0, primaryKey: false, nullable: false, ColumnCategory.Text, description: "Internal Microsoft Help ID for this Namespace (required)."), + new ColumnDefinition("File_Collection", ColumnType.String, 72, primaryKey: false, nullable: false, ColumnCategory.Identifier, keyTable: "File", keyColumn: 1, description: "Key for HxC (Collection) file (required).", modularizeType: ColumnModularizeType.Column), + new ColumnDefinition("Description", ColumnType.Localized, 0, primaryKey: false, nullable: true, ColumnCategory.Text, description: "Friendly name for Namespace (optional)."), + }, + symbolIdIsPrimaryKey: true + ); + + public static readonly TableDefinition HelpPlugin = new TableDefinition( + "HelpPlugin", + VSSymbolDefinitions.HelpPlugin, + new[] + { + new ColumnDefinition("HelpNamespace_", ColumnType.String, 72, primaryKey: true, nullable: false, ColumnCategory.Identifier, keyTable: "HelpNamespace", keyColumn: 1, description: "Foreign key into HelpNamespace table for the child namespace that will be plugged into the parent namespace (required)."), + new ColumnDefinition("HelpNamespace_Parent", ColumnType.String, 72, primaryKey: true, nullable: false, ColumnCategory.Identifier, keyTable: "HelpNamespace", keyColumn: 1, description: "Foreign key into HelpNamespace table for the parent namespace into which the child will be inserted (required)."), + new ColumnDefinition("File_HxT", ColumnType.String, 72, primaryKey: false, nullable: true, ColumnCategory.Identifier, keyTable: "File", keyColumn: 1, description: "Key for HxT file of child namespace (optional).", modularizeType: ColumnModularizeType.Column), + new ColumnDefinition("File_HxA", ColumnType.String, 72, primaryKey: false, nullable: true, ColumnCategory.Identifier, keyTable: "File", keyColumn: 1, description: "Key for HxA (Attributes) file of child namespace (optional).", modularizeType: ColumnModularizeType.Column), + new ColumnDefinition("File_ParentHxT", ColumnType.String, 72, primaryKey: false, nullable: true, ColumnCategory.Identifier, keyTable: "File", keyColumn: 1, description: "Key for HxT file of parent namespace that now includes the new child namespace (optional).", modularizeType: ColumnModularizeType.Column), + }, + symbolIdIsPrimaryKey: false + ); + + public static readonly TableDefinition[] All = new[] + { + HelpFile, + HelpFileToNamespace, + HelpFilter, + HelpFilterToNamespace, + HelpNamespace, + HelpPlugin, + }; + } +} diff --git a/src/ext/VisualStudio/wixext/VSWindowsInstallerBackendBinderExtension.cs b/src/ext/VisualStudio/wixext/VSWindowsInstallerBackendBinderExtension.cs new file mode 100644 index 00000000..d0d8648c --- /dev/null +++ b/src/ext/VisualStudio/wixext/VSWindowsInstallerBackendBinderExtension.cs @@ -0,0 +1,13 @@ +// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information. + +namespace WixToolset.VisualStudio +{ + using System.Collections.Generic; + using WixToolset.Data.WindowsInstaller; + using WixToolset.Extensibility; + + public class VSWindowsInstallerBackendBinderExtension : BaseWindowsInstallerBackendBinderExtension + { + public override IReadOnlyCollection TableDefinitions => VSTableDefinitions.All; + } +} diff --git a/src/ext/VisualStudio/wixext/WixToolset.VisualStudio.wixext.csproj b/src/ext/VisualStudio/wixext/WixToolset.VisualStudio.wixext.csproj new file mode 100644 index 00000000..20282720 --- /dev/null +++ b/src/ext/VisualStudio/wixext/WixToolset.VisualStudio.wixext.csproj @@ -0,0 +1,30 @@ + + + + + + netstandard2.0 + WixToolset.VisualStudio + WiX Toolset Visual Studio Extension + WiX Toolset VS Extension + true + true + + + + + + + + + + + + + + + + + + + diff --git a/src/ext/VisualStudio/wixext/WixToolset.VisualStudio.wixext.nuspec b/src/ext/VisualStudio/wixext/WixToolset.VisualStudio.wixext.nuspec new file mode 100644 index 00000000..51c9708e --- /dev/null +++ b/src/ext/VisualStudio/wixext/WixToolset.VisualStudio.wixext.nuspec @@ -0,0 +1,23 @@ + + + + $id$ + $version$ + $title$ + $description$ + $authors$ + MS-RL + false + $copyright$ + $projectUrl$ + + + + + + + + + + + diff --git a/src/ext/VisualStudio/wixext/WixToolset.VisualStudio.wixext.targets b/src/ext/VisualStudio/wixext/WixToolset.VisualStudio.wixext.targets new file mode 100644 index 00000000..4542375f --- /dev/null +++ b/src/ext/VisualStudio/wixext/WixToolset.VisualStudio.wixext.targets @@ -0,0 +1,8 @@ + + + + + + + + diff --git a/src/ext/VisualStudio/wixext/WixToolset.VisualStudio.wixext.v3.ncrunchproject b/src/ext/VisualStudio/wixext/WixToolset.VisualStudio.wixext.v3.ncrunchproject new file mode 100644 index 00000000..56556a9f --- /dev/null +++ b/src/ext/VisualStudio/wixext/WixToolset.VisualStudio.wixext.v3.ncrunchproject @@ -0,0 +1,7 @@ + + + + ..\..\build\Debug\vs.wixlib + + + \ No newline at end of file -- cgit v1.2.3-55-g6feb