path: root/src/Qt.DotNet.Adapter/build/Qt.DotNet.targets

<?xml version="1.0" encoding="utf-8"?>
<!--
****************************************************************************************************
 Copyright (C) 2025 The Qt Company Ltd.
 SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
****************************************************************************************************
-->
<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

  <Import
    Condition="'$(QtDotNetPropsImported)' != 'true'"
    Project="$(MSBuildThisFileDirectory)Qt.DotNet.props"/>

  <!--
  //////////////////////////////////////////////////////////////////////////////////////////////////
  // QtDotNetSetupQml
  -->
  <Target Name="QtDotNetSetupQml" Outputs="@(Qml);@(QmlModule)">
    <ItemGroup>
      <!-- Set QML file properties -->
      <Qml>
        <IsRoot Condition="'%(RelativeDir)' == ''">true</IsRoot>
        <IsRoot Condition="'%(RelativeDir)' != ''">false</IsRoot>
      </Qml>
      <Qml>
        <SourceDir Condition="%(IsRoot)">Application\</SourceDir>
        <SourceDir Condition="!%(IsRoot)">%(RelativeDir)</SourceDir>
      </Qml>
      <Qml>
        <Uri>$([System.String]::Copy(%(SourceDir))
                .Replace('\','/').Replace('/','.').Trim('.'))</Uri>
        <TypeName>%(FileName)</TypeName>
      </Qml>
      <QmlModule Include="%(Qml.Uri)">
        <IsRoot>%(Qml.IsRoot)</IsRoot>
        <SourceDir>%(Qml.SourceDir)</SourceDir>
      </QmlModule>
    </ItemGroup>
  </Target>

  <!--
  //////////////////////////////////////////////////////////////////////////////////////////////////
  // QtDotNetAddQmlFiles
  -->
  <Target Name="QtDotNetAddQmlFiles" BeforeTargets="CoreCompile" DependsOnTargets="QtDotNetSetupQml"
    Inputs="@(Qml)" Outputs="$(ProjectDir)$(IntermediateOutputPath)$(QtQmlFilesCs)"
    Condition="'$(DesignTimeBuild)' != 'true'">
    <!-- Copy QML files to native source dir -->
    <Copy Condition="'@(Qml)' != ''"
      SourceFiles="$(ProjectDir)%(RelativeDir)%(Filename)%(Extension)"
      DestinationFolder="$(IntermediateOutputPath)$(QtQmlSourceDir)%(SourceDir)" />
    <MakeDir Condition="'@(Qml)' != ''"
      Directories="$(IntermediateOutputPath)qtdotnet\csharp" />
    <!-- Add C# source with paths of QML files; this will be an input for code generation -->
    <WriteLinesToFile Condition="'@(Qml)' != ''" Overwrite="true" WriteOnlyWhenDifferent="false"
      File="$(ProjectDir)$(IntermediateOutputPath)$(QtQmlFilesCs)"
      Lines="@(Qml->'[assembly: Qt.Quick.QmlFile(
    Uri = &quot;%(Uri)&quot;, TypeName = &quot;%(TypeName)&quot;, IsRoot = %(IsRoot),
    Path = @&quot;%(SourceDir)%(Filename)%(Extension)&quot;)]')" />
    <ItemGroup>
      <Compile Condition="'@(Qml)' != ''"
        Include="$(IntermediateOutputPath)qtdotnet\csharp\QmlFiles.cs" />
    </ItemGroup>
  </Target>
  <!-- END QtDotNetAddQmlFiles -->

  <!--
  //////////////////////////////////////////////////////////////////////////////////////////////////
  // QtCheckVisualStudioWorkloads
  -->
  <Target Name="QtCheckVisualStudioWorkloads"
          BeforeTargets="QtDotNetGenerate"
          Condition="'$(OS)'=='Windows_NT' and '$(QtVsCheckWorkloads)'=='true'">

    <Warning Condition="!Exists('$(VsWhereExe)')"
             Text="vswhere.exe not found '$(VsWhereExe)'. Ignore workload check." />
    <PropertyGroup Condition="!Exists('$(VsWhereExe)')">
      <SkipWorkloadCheck>true</SkipWorkloadCheck>
    </PropertyGroup>

    <!-- Desktop C++ -->
    <Exec Condition="'$(SkipWorkloadCheck)'!='true'"
          Command="&quot;$(VsWhereExe)&quot; -nologo -products * -format json -requires &quot;$(DesktopWorkload)&quot;"
          ConsoleToMSBuild="true"
          IgnoreExitCode="true">
      <Output TaskParameter="ConsoleOutput" PropertyName="VsDesktopJson" />
    </Exec>

    <Error Condition="'$(SkipWorkloadCheck)'!='true'
           and ($([System.String]::Copy('$(VsDesktopJson)').Trim()) == ''
           or $([System.String]::Copy('$(VsDesktopJson)').Trim()) == '[]')"
           Text="Missing workload: Desktop development with C++. Please install via the Visual Studio Installer." />

    <!-- Optional: cross-platform C++ -->
    <Exec Condition="'$(SkipWorkloadCheck)'!='true' and '$(QtVsCheckCrossPlat)'=='true'"
          Command="&quot;$(VsWhereExe)&quot; -nologo -products * -format json -requires &quot;$(CrossPlatformWorkload)&quot;"
          ConsoleToMSBuild="true"
          IgnoreExitCode="true">
      <Output TaskParameter="ConsoleOutput" PropertyName="VsCrossJson" />
    </Exec>

    <Error Condition="'$(SkipWorkloadCheck)'!='true' and '$(QtVsCheckCrossPlat)'=='true'
           and ($([System.String]::Copy('$(VsCrossJson)').Trim()) == ''
           or $([System.String]::Copy('$(VsCrossJson)').Trim()) == '[]')"
           Text="Missing workload: Linux, Mac, and embedded development with C++. Please install via the Visual Studio Installer." />
  </Target>
  <!-- END QtCheckVisualStudioWorkloads -->

  <!--
  //////////////////////////////////////////////////////////////////////////////////////////////////
  // QtDotNetGenerate
  -->
  <Target Name="QtDotNetGenerate" AfterTargets="CoreCompile" BeforeTargets="_CreateAppHost"
    DependsOnTargets="QtDotNetAddQmlFiles"
    Inputs="$(TargetPath);$(ProjectDir)$(IntermediateOutputPath)$(TargetFileName)"
    Outputs="@(QtDotNetNativeSource)"
    Condition="'$(DesignTimeBuild)' != 'true'">

    <Message Importance="high" Text="Qt/.NET: Generating native code..." />

    <Error Condition="'$(QtDotNetGen)' == '' OR !Exists('$(QtDotNetGen)')"
      Text="Error: Qt/.NET generator tool not found" />
    <Error Condition="'$(QtDotNetGenRules)' == '' OR !Exists('$(QtDotNetGenRules)')"
      Text="Error: Qt/.NET generations rules not found" />
    <Error Condition="'$(QtDotNetAdapter)' == '' OR !Exists('$(QtDotNetAdapter)')"
      Text="Error: Qt/.NET adapter tool not found" />
    <Error Condition="'$(QtDotNetLib)' == '' OR !Exists('$(QtDotNetLib)/qdotnethost.h')"
      Text="Error: Qt/.NET library not found" />

    <PropertyGroup>
      <ProjectIntermediateDir>$(ProjectDir)$(IntermediateOutputPath)</ProjectIntermediateDir>
      <QtGenCmd
        >$(QtGenCmd) --source "$(ProjectIntermediateDir)$(TargetFileName)"</QtGenCmd>
      <QtGenCmd
        >$(QtGenCmd) --target "$(ProjectIntermediateDir)qtdotnet\native"</QtGenCmd>
      <QtGenCmd
        >$(QtGenCmd) @(_ResolvedProjectReferencePaths->'--ref &quot;%(Identity)&quot;', ' ')</QtGenCmd>
      <QtGenCmd
        >$(QtGenCmd) @(RuntimeCopyLocalItems->'--ref &quot;%(Identity)&quot;', ' ')</QtGenCmd>
    </PropertyGroup>

    <Message Importance="high" Text="$(QtGenCmd)" />
    <Exec Command="$(QtGenCmd)" EchoOff="true" IgnoreExitCode="true">
      <Output TaskParameter="ExitCode" PropertyName="QtGenResult" />
    </Exec>
    <Error Condition="'$(QtGenResult)' != '0'" Text="Error generating native code!" />
    <WriteLinesToFile Overwrite="true" WriteOnlyWhenDifferent="true"
      File="$(IntermediateOutputPath)qtdotnet\native\source\qtdotnet.cmake"
      Lines="include_directories(&quot;$(QtDotNetLib.Replace('\', '/'))&quot;)" />
    <ItemGroup>
      <QtDotNetNativeSource Include="$(IntermediateOutputPath)qtdotnet\native\source\**\*" />
    </ItemGroup>
  </Target>
  <!-- END QtDotNetGenerate-->

  <!--
  //////////////////////////////////////////////////////////////////////////////////////////////////
  // QtDotNetBuild
  -->
  <Target Name="QtDotNetBuild"
    DependsOnTargets="QtDotNetGenerate" BeforeTargets="_CreateAppHost"
    Inputs="@(QtDotNetNativeSource)" Outputs="@(QtDotNetNativeBuild)"
    Condition="'$(DesignTimeBuild)' != 'true'">

    <Message Importance="high" Text="Qt/.NET: Building native code..." />

    <PropertyGroup Condition="'$(VsInstallRoot)' == ''">
      <VsWhereCmd>"$(VsWhereExe)"</VsWhereCmd>
      <VsWhereCmd>$(VsWhereCmd) -latest</VsWhereCmd>
      <VsWhereCmd>$(VsWhereCmd) -property installationPath</VsWhereCmd>
    </PropertyGroup>
    <Exec Condition="'$(VsInstallRoot)' == ''" Command="$(VsWhereCmd)" ConsoleToMsBuild="true">
      <Output TaskParameter="ConsoleOutput" ItemName="VsWhereOutput" />
    </Exec>
    <PropertyGroup Condition="'$(VsInstallRoot)' == ''">
      <VsInstallRoot Condition="Exists('%(VsWhereOutput.Identity)')">%(VsWhereOutput.Identity)</VsInstallRoot>
    </PropertyGroup>
    <PropertyGroup Condition="'$(VsInstallRoot)' == '' OR '$(QtBuildSystem)' == 'ninja'">
      <CMakeBuild>true</CMakeBuild>
    </PropertyGroup>

    <MakeDir Directories="$(IntermediateOutputPath)qtdotnet\native\build" />
    <RemoveDir Directories="$(IntermediateOutputPath)qtdotnet\native\bin" />
    <MakeDir Directories="$(IntermediateOutputPath)qtdotnet\native\bin" />
    <PropertyGroup>
      <CMakeCmd>
        CALL "$(VsInstallRoot)\VC\Auxiliary\Build\vcvars64.bat" &gt; NUL
        SET CMAKE_PREFIX_PATH=$(QtDir);%CMAKE_PREFIX_PATH%"
        CD "$(IntermediateOutputPath)qtdotnet\native\build"
      </CMakeCmd>
      <CMakeCmd Condition="'$(CMakeBuild)' != 'true'">
        $(CMakeCmd)
        cmake ..\source -DCMAKE_PROJECT_INCLUDE=qtdotnet.cmake -G "Visual Studio 17 2022"
      </CMakeCmd>
      <CMakeCmd Condition="'$(CMakeBuild)' == 'true'">
        $(CMakeCmd)
        cmake ..\source -DCMAKE_PROJECT_INCLUDE=qtdotnet.cmake -G Ninja -DCMAKE_BUILD_TYPE=Release
        cmake --build . --parallel
      </CMakeCmd>
    </PropertyGroup>
    <Exec Command="$(CMakeCmd)" EchoOff="true" IgnoreExitCode="true">
      <Output TaskParameter="ExitCode" PropertyName="CMakeResult" />
    </Exec>
    <Error Condition="'$(CMakeResult)' != '0'" Text="Error building native code!" />

    <ItemGroup Condition="'$(CMakeBuild)' != 'true'">
      <NativeSln Include="$(IntermediateOutputPath)qtdotnet\native\build\*.sln" />
    </ItemGroup>
    <PropertyGroup Condition="'$(CMakeBuild)' != 'true'">
      <NativeApp>%(NativeSln.RelativeDir)%(NativeSln.Filename)</NativeApp>
    </PropertyGroup>
    <ItemGroup Condition="'$(CMakeBuild)' != 'true'">
      <NativeProject Include="$(NativeApp)_tooling.vcxproj;
                              $(NativeApp)_qmlimportscan.vcxproj;
                              $(NativeApp)_autogen.vcxproj;
                              $(NativeApp)_automoc_json_extraction.vcxproj;
                              $(NativeApp).vcxproj" />
      <NativeProject Remove="@(NativeProject)" Condition="!Exists('%(NativeProject.FullPath)')" />
    </ItemGroup>
    <MSBuild Condition="'$(CMakeBuild)' != 'true'"
      Projects="@(NativeProject)" BuildInParallel="false" StopOnFirstFailure="true"
      Properties="Platform=x64;Configuration=Release;CL_MP=true" Targets="Build" />
  </Target>
  <!-- END QtDotNetBuild-->

  <!--
  //////////////////////////////////////////////////////////////////////////////////////////////////
  // QtDotNetReplaceBinary
  -->
  <Target Name="QtDotNetReplaceBinary"
    AfterTargets="QtDotNetBuild" BeforeTargets="_CreateAppHost"
    Inputs="$(TargetPath)" Outputs="$(AppHostSourcePath)"
    Condition="'$(DesignTimeBuild)' != 'true'">

    <Message Importance="high" Text="Qt/.NET: Replacing native host binary..." />

    <ItemGroup>
      <QtNativeBinary Include="$(IntermediateOutputPath)qtdotnet\native\bin\*.exe" />
    </ItemGroup>
    <PropertyGroup>
      <QtNativeHostPath Condition="Exists('%(QtNativeBinary.FullPath)')"
        >%(QtNativeBinary.FullPath)</QtNativeHostPath>
    </PropertyGroup>
    <Error Condition="'$(QtNativeHostPath)' == ''"
      Text="ERROR: Missing native host binary" />
    <Touch Files="$(QtNativeHostPath)" />
    <PropertyGroup>
      <AppHostSourcePath>$(QtNativeHostPath)</AppHostSourcePath>
    </PropertyGroup>
  </Target>
  <!-- END QtDotNetReplaceBinary-->

  <!--
  //////////////////////////////////////////////////////////////////////////////////////////////////
  // QtDotNetDeploy
  -->
  <Target Name="QtDotNetDeploy"
    AfterTargets="CopyFilesToOutputDirectory" DependsOnTargets="QtDotNetBuild"
    Inputs="$(RunCommand)" Outputs="$(TargetDir)qtdeploy.txt"
    Condition="'$(DesignTimeBuild)' != 'true'">

    <Message Importance="high" Text="Qt/.NET: Deploying Qt..." />

    <PropertyGroup Condition="'$(VsInstallRoot)' == ''">
      <VsWhereCmd>"$(VsWhereExe)"</VsWhereCmd>
      <VsWhereCmd>$(VsWhereCmd) -latest</VsWhereCmd>
      <VsWhereCmd>$(VsWhereCmd) -property installationPath</VsWhereCmd>
    </PropertyGroup>
    <Exec Condition="'$(VsInstallRoot)' == ''" Command="$(VsWhereCmd)" ConsoleToMsBuild="true">
      <Output TaskParameter="ConsoleOutput" ItemName="VsWhereOutput" />
    </Exec>
    <PropertyGroup Condition="'$(VsInstallRoot)' == ''">
      <VsInstallRoot Condition="Exists('%(VsWhereOutput.Identity)')"
        >%(VsWhereOutput.Identity)</VsInstallRoot>
    </PropertyGroup>

    <PropertyGroup>
      <VcVarsCmd Condition="'$(VsInstallRoot)' != ''"
        >CALL "$(VsInstallRoot)\VC\Auxiliary\Build\vcvars64.bat" &gt; NUL</VcVarsCmd>
      <DeployCmd>"$(QtDir)\bin\windeployqt.exe"</DeployCmd>
      <DeployCmd>$(DeployCmd) --qmldir "$(ProjectDir.TrimEnd('\'))"</DeployCmd>
      <DeployCmd>$(DeployCmd) --no-translations --release</DeployCmd>
      <DeployCmd>$(DeployCmd) --no-compiler-runtime</DeployCmd>
      <DeployCmd>$(DeployCmd) "$(RunCommand)"</DeployCmd>
      <DeployCmd>$(DeployCmd) &gt; NUL</DeployCmd>
    </PropertyGroup>
    <Exec Command="
          $(VcVarsCmd)
          $(DeployCmd)"
      WorkingDirectory="$(TargetDir)" IgnoreExitCode="true">
      <Output TaskParameter="ExitCode" PropertyName="DeployResult" />
    </Exec>
    <Error Condition="'$(DeployResult)' != '0'" Text="Error deploying Qt binaries!" />
    <Exec WorkingDirectory="$(TargetDir)" IgnoreExitCode="true"
      Command="$(DeployCmd) --list relative &gt; qtdeploy.txt 2&gt; NUL" />

    <ItemGroup>
      <QmlDeploy Condition="'@(Qml)' != ''"
        Include="$(ProjectDir)$(IntermediateOutputPath)$(QtQmlSourceDir)%(Qml.SourceDir)*">
        <SourceDir>%(Qml.SourceDir)</SourceDir>
      </QmlDeploy>
    </ItemGroup>
    <Copy Condition="'@(QmlDeploy)' != ''"
      SourceFiles="%(Identity)"
      DestinationFolder="$(TargetDir)%(SourceDir)" />
    <WriteLinesToFile Condition="'@(QmlDeploy)' != ''"
      File="$(TargetDir)qtdeploy.txt" Overwrite="false"
      Lines="%(SourceDir)%(Filename)%(Extension)" />
  </Target>
  <!-- END QtDotNetDeploy-->

  <!--
  //////////////////////////////////////////////////////////////////////////////////////////////////
  // QtDotNetClean
  -->
  <Target Name="QtDotNetClean" AfterTargets="Clean">
    <RemoveDir Directories="$(IntermediateOutputPath)qtdotnet" />
    <ReadLinesFromFile Condition="Exists('$(TargetDir)qtdeploy.txt')"
      File="$(TargetDir)qtdeploy.txt">
      <Output TaskParameter="Lines" ItemName="QtDeploy"/>
    </ReadLinesFromFile>
    <Delete Files="@(QtDeploy->'$(TargetDir)%(Identity)')" />
    <Delete Files="$(TargetDir)qtdeploy.txt" />
    <RemoveDir Condition="$([System.String]::Copy('%(QtDeploy.Identity)').Contains('\'))"
       Directories="$(TargetDir)$([System.IO.Path]::GetDirectoryName(%(QtDeploy.Identity)).Split('\')[0])" />
  </Target>
  <!-- END QtDotNetClean-->

</Project>