common.tt

<#@template hostspecific="true" language="C#" #>
<#@assembly Name="System.Core" #>
<#@assembly Name="System.Xml" #>
<#@assembly Name="System.Xml.Linq" #>
<#@import namespace="System" #>
<#@import namespace="System.Collections.Generic" #>
<#@import namespace="System.IO" #>
<#@import namespace="System.Linq" #>
<#@import namespace="System.Text" #>
<#@import namespace="System.Xml" #>
<#@import namespace="System.Xml.Linq" #>
<#@assembly name="$(AssemblyRef_Microsoft_VisualStudio_Interop)" #>
<#@assembly name="$(AssemblyRef_EnvDTE)" #>
<#@import namespace="EnvDTE" #>
<#@assembly name="$(VsSdk_Shell_Interop)" #>
<#@import namespace="Microsoft.VisualStudio.Shell.Interop" #>
<#
// Copyright (C) 2025 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0

    DTE Dte = null;
    try {
        Dte = ((IServiceProvider)Host)?.GetService(typeof(DTE)) as DTE;
    } catch {
    }

    IVsShell VsShell = null;
    try {
        VsShell = ((IServiceProvider)Host)?.GetService(typeof(SVsShell)) as IVsShell;
    } catch {
    }

    string SolutionDir = Host?.ResolveParameterValue("-", "-", "SolutionDir");
    if (string.IsNullOrEmpty(SolutionDir)) {
        if (Dte != null)
            SolutionDir = Path.GetDirectoryName(Dte.Solution.FullName);
        else
            throw new Exception("Unable to obtain 'SolutionDir' parameter.");
    }

    string DevEnvDir = Host?.ResolveParameterValue("-", "-", "DevEnvDir");
    if (string.IsNullOrEmpty(DevEnvDir)) {
        if (VsShell != null) {
            object vsShellPropValue = null;
            VsShell.GetProperty((int)__VSSPROPID.VSSPROPID_InstallDirectory, out vsShellPropValue);
            DevEnvDir = vsShellPropValue as string;
            if (string.IsNullOrEmpty(DevEnvDir))
                throw new Exception("Unable to obtain 'DevEnvDir' parameter.");
        } else {
            throw new Exception("Unable to obtain 'DevEnvDir' parameter.");
        }
    }

    string VS_VERSION = Host?.ResolveParameterValue("-", "-", "VisualStudioVersion");
    if (string.IsNullOrEmpty(VS_VERSION)) {
        if (Dte != null)
            VS_VERSION = Dte.Version;
        else
            throw new Exception("Unable to obtain 'VisualStudioVersion' parameter.");
    }

    string VS_NAME;
    if (VS_VERSION.StartsWith("18."))
        VS_NAME = "2026";
    else if (VS_VERSION.StartsWith("17."))
        VS_NAME = "2022";
    else if (VS_VERSION.StartsWith("16."))
        VS_NAME = "2019";
    else
        throw new Exception($"Cannot set VS_NAME, unknown VS_VERSION: {VS_VERSION}");

    string VC_TARGETS_PATH = Host?.ResolveParameterValue("-", "-", "VCTargetsPath");

    if (string.IsNullOrEmpty(VC_TARGETS_PATH) && !string.IsNullOrEmpty(VS_VERSION)) {
        var proc = System.Diagnostics.Process.Start(new System.Diagnostics.ProcessStartInfo
        {
            FileName = Path.Combine(Environment.GetEnvironmentVariable("ProgramFiles(x86)"),
                @"Microsoft Visual Studio\Installer\vswhere.exe"),
            Arguments = string.Format(@"-property installationPath -latest -Version [{0})",
                VS_VERSION.StartsWith("18.") ? "18.0,19.0" :
                VS_VERSION.StartsWith("17.") ? "17.0,18.0" :
                VS_VERSION.StartsWith("16.") ? "16.0,17.0" : string.Empty),
            WorkingDirectory = Directory.GetParent(SolutionDir).FullName,
            CreateNoWindow = true,
            UseShellExecute = false,
            RedirectStandardOutput = true,
            RedirectStandardError = true,
        });
        if (proc.WaitForExit(3000) && proc.ExitCode == 0)
            VC_TARGETS_PATH = proc.StandardOutput.ReadLine();
    }

    if (string.IsNullOrEmpty(VC_TARGETS_PATH)) {
        if (Dte != null && !string.IsNullOrEmpty(VS_VERSION)) {
            VC_TARGETS_PATH = Path.Combine(Environment.GetEnvironmentVariable(
                    VS_VERSION.StartsWith("18.") || VS_VERSION.StartsWith("17.")
                        ? "ProgramFiles"        // 64-bit VS
                        : "ProgramFiles(x86)"), // 32-bit VS 2019 / older
                VS_VERSION.StartsWith("18.") ? $@"Microsoft Visual Studio\18\{Dte.Edition}\MSBuild\Microsoft\VC\v180" :
                VS_VERSION.StartsWith("17.") ? $@"Microsoft Visual Studio\{VS_NAME}\{Dte.Edition}\MSBuild\Microsoft\VC\v170" :
                VS_VERSION.StartsWith("16.") ? $@"Microsoft Visual Studio\{VS_NAME}\{Dte.Edition}\MSBuild\Microsoft\VC\v160" :
                throw new Exception($"Unsupported Visual Studio version {VS_VERSION} for 'VCTargetsPath'."));
        } else {
            throw new Exception("Unable to obtain 'VCTargetsPath' parameter.");
        }
    }

    string VS_TARGET_ARCH = Environment.GetEnvironmentVariable("VSCMD_ARG_TGT_ARCH") ?? "x64";

/***************************************************************************/
    string WARNING_GENERATED_FILE = "This file was generated automatically.";
    string XML_COMMENT_BEGIN      = "<!--";
    string XML_COMMENT_END        = "-->";

    XML_COMMENT_BEGIN = XML_COMMENT_BEGIN.ToString();
    XML_COMMENT_END = XML_COMMENT_END.ToString();

    var XmlLoad = new Func<string, XElement>(xmlText =>
    {
        XDocument xmlDoc = null;
        using (var reader = XmlReader.Create(new StringReader(xmlText)))
            xmlDoc = XDocument.Load(reader);
        var xmlRoot = xmlDoc.Root;
        xmlRoot.Descendants().ToList().ForEach(x => x.Name = x.Name.LocalName);
        return xmlRoot;
    });

    var XmlPrint = new Func<IEnumerable<XElement>, string>(x =>
    {
        var xmlOut = new StringBuilder();
        var xmlOutSettings = new XmlWriterSettings()
        {
            ConformanceLevel = ConformanceLevel.Fragment,
            OmitXmlDeclaration = true,
            Indent = true,
        };
        using (var xmlOutWriter = XmlWriter.Create(xmlOut, xmlOutSettings)) {
            foreach (var y in x)
                y.WriteTo(xmlOutWriter);
        }
        return xmlOut.ToString();
    });

#>