From af559385380dfe2a5dc1f2d9f11d5c6deab2555b Mon Sep 17 00:00:00 2001
From: Shawn Hoffman <godisgovernment@gmail.com>
Date: Fri, 21 Aug 2020 01:18:14 -0700
Subject: [PATCH] msbuild: use the moc dispatcher from Qt's vstools The new
 method supports build parallelism and cleaner integration into msbuild
 dependency flows.

---
 Source/Core/DolphinQt/DolphinQt.vcxproj |  399 +++-----
 Source/VSProps/QtCompile.props          |   60 +-
 Source/VSProps/QtCompile.targets        |   10 -
 Source/VSProps/qt_globals.targets       |  558 ++++++++++++
 Source/VSProps/qt_tasks.targets         | 1110 +++++++++++++++++++++++
 Source/VSProps/qtmoc.props              |   83 ++
 Source/VSProps/qtmoc.targets            |  510 +++++++++++
 Source/VSProps/qtmoc_cl.targets         |   49 +
 8 files changed, 2465 insertions(+), 314 deletions(-)
 delete mode 100644 Source/VSProps/QtCompile.targets
 create mode 100644 Source/VSProps/qt_globals.targets
 create mode 100644 Source/VSProps/qt_tasks.targets
 create mode 100644 Source/VSProps/qtmoc.props
 create mode 100644 Source/VSProps/qtmoc.targets
 create mode 100644 Source/VSProps/qtmoc_cl.targets

diff --git a/Source/Core/DolphinQt/DolphinQt.vcxproj b/Source/Core/DolphinQt/DolphinQt.vcxproj
index 8e29973648..89ecbafd2e 100644
--- a/Source/Core/DolphinQt/DolphinQt.vcxproj
+++ b/Source/Core/DolphinQt/DolphinQt.vcxproj
@@ -21,7 +21,6 @@
     <ClCompile>
       <!-- 5054  operator '+': deprecated between enumerations of different types (in Qt headers) -->
       <DisableSpecificWarnings>5054;%(DisableSpecificWarnings)</DisableSpecificWarnings>
-
       <AdditionalIncludeDirectories>($ProjectDir)Config\Graphics;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <AdditionalIncludeDirectories>$(ProjectDir)Config;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <AdditionalIncludeDirectories>$(ProjectDir)Config\ControllerInterface;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
@@ -44,268 +43,7 @@
       <AdditionalManifestFiles>DolphinQt.manifest;%(AdditionalManifestFiles)</AdditionalManifestFiles>
     </Manifest>
   </ItemDefinitionGroup>
-  <!--
-  MOC files need to be listed. Put headers here ONLY if they use Q_OBJECT. Otherwise, put them
-  in the ItemGroup for ClInclude.
-  -->
-  <!--NOTE: When adding moc'd files, you must list outputs in the ClCompile ItemGroup too!-->
   <ItemGroup>
-    <QtMoc Include="AboutDialog.h" />
-    <QtMoc Include="CheatsManager.h" />
-    <QtMoc Include="Config\ARCodeWidget.h" />
-    <QtMoc Include="Config\CheatCodeEditor.h" />
-    <QtMoc Include="Config\CheatWarningWidget.h" />
-    <QtMoc Include="Config\ControllerInterface\ControllerInterfaceWindow.h" />
-    <QtMoc Include="Config\ControllerInterface\DualShockUDPClientAddServerDialog.h" />
-    <QtMoc Include="Config\ControllerInterface\DualShockUDPClientWidget.h" />
-    <QtMoc Include="Config\ControllerInterface\ServerStringValidator.h" />
-    <QtMoc Include="Config\ControllersWindow.h" />
-    <QtMoc Include="Config\FilesystemWidget.h" />
-    <QtMoc Include="Config\GameConfigEdit.h" />
-    <QtMoc Include="Config\GameConfigHighlighter.h" />
-    <QtMoc Include="Config\GameConfigWidget.h" />
-    <QtMoc Include="Config\GeckoCodeWidget.h" />
-    <QtMoc Include="Config\Graphics\AdvancedWidget.h" />
-    <QtMoc Include="Config\Graphics\EnhancementsWidget.h" />
-    <QtMoc Include="Config\Graphics\GeneralWidget.h" />
-    <QtMoc Include="Config\Graphics\GraphicsBool.h" />
-    <QtMoc Include="Config\Graphics\GraphicsChoice.h" />
-    <QtMoc Include="Config\Graphics\GraphicsInteger.h" />
-    <QtMoc Include="Config\Graphics\GraphicsRadio.h" />
-    <QtMoc Include="Config\Graphics\GraphicsSlider.h" />
-    <QtMoc Include="Config\Graphics\GraphicsWidget.h" />
-    <QtMoc Include="Config\Graphics\GraphicsWindow.h" />
-    <QtMoc Include="Config\Graphics\HacksWidget.h" />
-    <QtMoc Include="Config\Graphics\PostProcessingConfigWindow.h" />
-    <QtMoc Include="Config\Graphics\SoftwareRendererWidget.h" />
-    <QtMoc Include="Config\InfoWidget.h" />
-    <QtMoc Include="Config\LogConfigWidget.h" />
-    <QtMoc Include="Config\LogWidget.h" />
-    <QtMoc Include="Config\Mapping\GCKeyboardEmu.h" />
-    <QtMoc Include="Config\Mapping\GCMicrophone.h" />
-    <QtMoc Include="Config\Mapping\GCPadEmu.h" />
-    <QtMoc Include="Config\Mapping\GCPadWiiUConfigDialog.h" />
-    <QtMoc Include="Config\Mapping\Hotkey3D.h" />
-    <QtMoc Include="Config\Mapping\HotkeyControllerProfile.h" />
-    <QtMoc Include="Config\Mapping\HotkeyDebugging.h" />
-    <QtMoc Include="Config\Mapping\HotkeyGeneral.h" />
-    <QtMoc Include="Config\Mapping\HotkeyGraphics.h" />
-    <QtMoc Include="Config\Mapping\HotkeyStates.h" />
-    <QtMoc Include="Config\Mapping\HotkeyStatesOther.h" />
-    <QtMoc Include="Config\Mapping\HotkeyTAS.h" />
-    <QtMoc Include="Config\Mapping\HotkeyWii.h" />
-    <QtMoc Include="Config\Mapping\IOWindow.h" />
-    <QtMoc Include="Config\Mapping\MappingButton.h" />
-    <QtMoc Include="Config\Mapping\MappingIndicator.h" />
-    <QtMoc Include="Config\Mapping\MappingNumeric.h" />
-    <QtMoc Include="Config\Mapping\MappingWidget.h" />
-    <QtMoc Include="Config\Mapping\MappingWindow.h" />
-    <QtMoc Include="Config\Mapping\WiimoteEmuExtension.h" />
-    <QtMoc Include="Config\Mapping\WiimoteEmuExtensionMotionInput.h" />
-    <QtMoc Include="Config\Mapping\WiimoteEmuExtensionMotionSimulation.h" />
-    <QtMoc Include="Config\Mapping\WiimoteEmuGeneral.h" />
-    <QtMoc Include="Config\Mapping\WiimoteEmuMotionControl.h" />
-    <QtMoc Include="Config\Mapping\WiimoteEmuMotionControlIMU.h" />
-    <QtMoc Include="Config\NewPatchDialog.h" />
-    <QtMoc Include="Config\PatchesWidget.h" />
-    <QtMoc Include="Config\PropertiesDialog.h" />
-    <QtMoc Include="Config\SettingsWindow.h" />
-    <QtMoc Include="Config\VerifyWidget.h" />
-    <QtMoc Include="ConvertDialog.h" />
-    <QtMoc Include="Debugger\BreakpointWidget.h" />
-    <QtMoc Include="Debugger\CodeViewWidget.h" />
-    <QtMoc Include="Debugger\CodeWidget.h" />
-    <QtMoc Include="Debugger\JITWidget.h" />
-    <QtMoc Include="Debugger\MemoryViewWidget.h" />
-    <QtMoc Include="Debugger\MemoryWidget.h" />
-    <QtMoc Include="Debugger\NetworkWidget.h" />
-    <QtMoc Include="Debugger\NewBreakpointDialog.h" />
-    <QtMoc Include="Debugger\PatchInstructionDialog.h" />
-    <QtMoc Include="Debugger\RegisterWidget.h" />
-    <QtMoc Include="Debugger\ThreadWidget.h" />
-    <QtMoc Include="Debugger\WatchWidget.h" />
-    <QtMoc Include="DiscordHandler.h" />
-    <QtMoc Include="DiscordJoinRequestDialog.h" />
-    <QtMoc Include="FIFO\FIFOAnalyzer.h" />
-    <QtMoc Include="FIFO\FIFOPlayerWindow.h" />
-    <QtMoc Include="GameList\GameList.h" />
-    <QtMoc Include="GameList\GameListModel.h" />
-    <QtMoc Include="GameList\GameTracker.h" />
-    <QtMoc Include="GameList\GridProxyModel.h" />
-    <QtMoc Include="GameList\ListProxyModel.h" />
-    <QtMoc Include="GCMemcardCreateNewDialog.h" />
-    <QtMoc Include="GCMemcardManager.h" />
-    <QtMoc Include="Host.h" />
-    <QtMoc Include="HotkeyScheduler.h" />
-    <QtMoc Include="MainWindow.h" />
-    <QtMoc Include="MenuBar.h" />
-    <QtMoc Include="NetPlay\ChunkedProgressDialog.h" />
-    <QtMoc Include="NetPlay\GameListDialog.h" />
-    <QtMoc Include="NetPlay\MD5Dialog.h" />
-    <QtMoc Include="NetPlay\NetPlayBrowser.h" />
-    <QtMoc Include="NetPlay\NetPlayDialog.h" />
-    <QtMoc Include="NetPlay\NetPlaySetupDialog.h" />
-    <QtMoc Include="NetPlay\PadMappingDialog.h" />
-    <QtMoc Include="NKitWarningDialog.h" />
-    <QtMoc Include="QtUtils\AspectRatioWidget.h" />
-    <QtMoc Include="QtUtils\BlockUserInputFilter.h" />
-    <QtMoc Include="QtUtils\DoubleClickEventFilter.h" />
-    <QtMoc Include="QtUtils\ElidedButton.h" />
-    <QtMoc Include="QtUtils\FileOpenEventFilter.h" />
-    <QtMoc Include="QtUtils\FlowLayout.h" />
-    <QtMoc Include="QtUtils\ModalMessageBox.h" />
-    <QtMoc Include="QtUtils\ParallelProgressDialog.h" />
-    <QtMoc Include="QtUtils\UTF8CodePointCountValidator.h" />
-    <QtMoc Include="QtUtils\WindowActivationEventFilter.h" />
-    <QtMoc Include="QtUtils\WrapInScrollArea.h" />
-    <QtMoc Include="RenderWidget.h" />
-    <QtMoc Include="SearchBar.h" />
-    <QtMoc Include="Settings.h" />
-    <QtMoc Include="Settings\AdvancedPane.h" />
-    <QtMoc Include="Settings\AudioPane.h" />
-    <QtMoc Include="Settings\GameCubePane.h" />
-    <QtMoc Include="Settings\GeneralPane.h" />
-    <QtMoc Include="Settings\InterfacePane.h" />
-    <QtMoc Include="Settings\PathPane.h" />
-    <QtMoc Include="Settings\USBDeviceAddToWhitelistDialog.h" />
-    <QtMoc Include="Settings\WiiPane.h" />
-    <QtMoc Include="TAS\GCTASInputWindow.h" />
-    <QtMoc Include="TAS\IRWidget.h" />
-    <QtMoc Include="TAS\StickWidget.h" />
-    <QtMoc Include="TAS\TASCheckBox.h" />
-    <QtMoc Include="TAS\TASInputWindow.h" />
-    <QtMoc Include="TAS\WiiTASInputWindow.h" />
-    <QtMoc Include="ToolBar.h" />
-    <QtMoc Include="Updater.h" />
-  </ItemGroup>
-  <!--TODO figure out how to get QtMoc to add outputs to ClCompile's inputs...-->
-  <ItemGroup>
-    <ClCompile Include="$(QtMocOutPrefix)AboutDialog.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)AdvancedPane.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)AdvancedWidget.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)ARCodeWidget.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)AspectRatioWidget.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)AudioPane.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)BlockUserInputFilter.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)BreakpointWidget.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)CheatCodeEditor.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)CheatsManager.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)CheatWarningWidget.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)ChunkedProgressDialog.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)CodeViewWidget.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)CodeWidget.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)ControllerInterfaceWindow.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)ControllersWindow.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)ConvertDialog.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)DiscordHandler.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)DiscordJoinRequestDialog.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)DoubleClickEventFilter.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)DualShockUDPClientAddServerDialog.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)DualShockUDPClientWidget.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)ElidedButton.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)EnhancementsWidget.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)FIFOAnalyzer.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)FIFOPlayerWindow.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)FileOpenEventFilter.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)FilesystemWidget.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)FlowLayout.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)GameConfigEdit.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)GameConfigHighlighter.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)GameConfigWidget.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)GameCubePane.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)GameList.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)GameListDialog.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)GameListModel.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)GameTracker.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)GCKeyboardEmu.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)GCMemcardCreateNewDialog.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)GCMemcardManager.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)GCMicrophone.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)GCPadEmu.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)GCPadWiiUConfigDialog.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)GCTASInputWindow.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)GeckoCodeWidget.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)GeneralPane.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)GeneralWidget.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)GraphicsBool.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)GraphicsChoice.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)GraphicsInteger.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)GraphicsRadio.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)GraphicsSlider.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)GraphicsWidget.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)GraphicsWindow.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)GridProxyModel.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)HacksWidget.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)Host.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)Hotkey3D.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)HotkeyControllerProfile.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)HotkeyDebugging.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)HotkeyGeneral.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)HotkeyGraphics.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)HotkeyScheduler.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)HotkeyStates.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)HotkeyStatesOther.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)HotkeyTAS.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)HotkeyWii.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)InfoWidget.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)InterfacePane.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)IOWindow.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)IRWidget.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)JITWidget.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)ListProxyModel.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)LogConfigWidget.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)LogWidget.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)MainWindow.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)MappingButton.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)MappingIndicator.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)MappingNumeric.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)MappingWidget.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)MappingWindow.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)MD5Dialog.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)MemoryViewWidget.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)MemoryWidget.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)MenuBar.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)ModalMessageBox.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)NetPlayBrowser.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)NetPlayDialog.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)NetPlaySetupDialog.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)NetworkWidget.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)NewBreakpointDialog.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)NewPatchDialog.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)NKitWarningDialog.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)PadMappingDialog.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)ParallelProgressDialog.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)PatchesWidget.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)PatchInstructionDialog.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)PathPane.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)PostProcessingConfigWindow.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)PropertiesDialog.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)RegisterWidget.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)RenderWidget.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)SearchBar.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)ServerStringValidator.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)Settings.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)SettingsWindow.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)SoftwareRendererWidget.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)StickWidget.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)TASCheckBox.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)TASInputWindow.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)ThreadWidget.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)ToolBar.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)Updater.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)USBDeviceAddToWhitelistDialog.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)UTF8CodePointCountValidator.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)VerifyWidget.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)WatchWidget.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)WiimoteEmuExtension.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)WiimoteEmuExtensionMotionInput.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)WiimoteEmuExtensionMotionSimulation.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)WiimoteEmuGeneral.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)WiimoteEmuMotionControl.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)WiimoteEmuMotionControlIMU.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)WiiPane.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)WiiTASInputWindow.cpp" />
-    <ClCompile Include="$(QtMocOutPrefix)WindowActivationEventFilter.cpp" />
     <ClCompile Include="AboutDialog.cpp" />
     <ClCompile Include="CheatsManager.cpp" />
     <ClCompile Include="Config\ARCodeWidget.cpp" />
@@ -442,7 +180,11 @@
     <ClCompile Include="Updater.cpp" />
     <ClCompile Include="WiiUpdate.cpp" />
   </ItemGroup>
-  <!--Put standard C/C++ headers here. Headers that are listed in the QtMoc ItemGroup must NOT be listed here.-->
+  <!--
+    Put C/C++ headers here. If moc needs to be run for the file (only needed if
+    Q_OBJECT is used in the file), set the item type to QtMoc. This list can
+    also be modified using the VS UI.
+    -->
   <ItemGroup>
     <ClInclude Include="Config\Mapping\MappingCommon.h" />
     <ClInclude Include="Debugger\RegisterColumn.h" />
@@ -455,6 +197,133 @@
     <ClInclude Include="Resources.h" />
     <ClInclude Include="Translation.h" />
     <ClInclude Include="WiiUpdate.h" />
+    <QtMoc Include="AboutDialog.h" />
+    <QtMoc Include="CheatsManager.h" />
+    <QtMoc Include="Config\ARCodeWidget.h" />
+    <ClInclude Include="Config\CheatCodeEditor.h" />
+    <QtMoc Include="Config\CheatWarningWidget.h" />
+    <QtMoc Include="Config\ControllerInterface\ControllerInterfaceWindow.h" />
+    <QtMoc Include="Config\ControllerInterface\DualShockUDPClientAddServerDialog.h" />
+    <QtMoc Include="Config\ControllerInterface\DualShockUDPClientWidget.h" />
+    <QtMoc Include="Config\ControllerInterface\ServerStringValidator.h" />
+    <QtMoc Include="Config\ControllersWindow.h" />
+    <QtMoc Include="Config\FilesystemWidget.h" />
+    <ClInclude Include="Config\GameConfigEdit.h" />
+    <QtMoc Include="Config\GameConfigHighlighter.h" />
+    <QtMoc Include="Config\GameConfigWidget.h" />
+    <QtMoc Include="Config\GeckoCodeWidget.h" />
+    <QtMoc Include="Config\Graphics\AdvancedWidget.h" />
+    <QtMoc Include="Config\Graphics\EnhancementsWidget.h" />
+    <QtMoc Include="Config\Graphics\GeneralWidget.h" />
+    <QtMoc Include="Config\Graphics\GraphicsBool.h" />
+    <QtMoc Include="Config\Graphics\GraphicsChoice.h" />
+    <QtMoc Include="Config\Graphics\GraphicsInteger.h" />
+    <QtMoc Include="Config\Graphics\GraphicsRadio.h" />
+    <QtMoc Include="Config\Graphics\GraphicsSlider.h" />
+    <QtMoc Include="Config\Graphics\GraphicsWidget.h" />
+    <QtMoc Include="Config\Graphics\GraphicsWindow.h" />
+    <QtMoc Include="Config\Graphics\HacksWidget.h" />
+    <QtMoc Include="Config\Graphics\PostProcessingConfigWindow.h" />
+    <QtMoc Include="Config\Graphics\SoftwareRendererWidget.h" />
+    <QtMoc Include="Config\InfoWidget.h" />
+    <QtMoc Include="Config\LogConfigWidget.h" />
+    <QtMoc Include="Config\LogWidget.h" />
+    <QtMoc Include="Config\Mapping\GCKeyboardEmu.h" />
+    <QtMoc Include="Config\Mapping\GCMicrophone.h" />
+    <QtMoc Include="Config\Mapping\GCPadEmu.h" />
+    <QtMoc Include="Config\Mapping\GCPadWiiUConfigDialog.h" />
+    <QtMoc Include="Config\Mapping\Hotkey3D.h" />
+    <QtMoc Include="Config\Mapping\HotkeyControllerProfile.h" />
+    <QtMoc Include="Config\Mapping\HotkeyDebugging.h" />
+    <QtMoc Include="Config\Mapping\HotkeyGeneral.h" />
+    <QtMoc Include="Config\Mapping\HotkeyGraphics.h" />
+    <QtMoc Include="Config\Mapping\HotkeyStates.h" />
+    <QtMoc Include="Config\Mapping\HotkeyStatesOther.h" />
+    <QtMoc Include="Config\Mapping\HotkeyTAS.h" />
+    <QtMoc Include="Config\Mapping\HotkeyWii.h" />
+    <QtMoc Include="Config\Mapping\IOWindow.h" />
+    <QtMoc Include="Config\Mapping\MappingButton.h" />
+    <ClInclude Include="Config\Mapping\MappingIndicator.h" />
+    <ClInclude Include="Config\Mapping\MappingNumeric.h" />
+    <QtMoc Include="Config\Mapping\MappingWidget.h" />
+    <QtMoc Include="Config\Mapping\MappingWindow.h" />
+    <QtMoc Include="Config\Mapping\WiimoteEmuExtension.h" />
+    <QtMoc Include="Config\Mapping\WiimoteEmuExtensionMotionInput.h" />
+    <QtMoc Include="Config\Mapping\WiimoteEmuExtensionMotionSimulation.h" />
+    <QtMoc Include="Config\Mapping\WiimoteEmuGeneral.h" />
+    <QtMoc Include="Config\Mapping\WiimoteEmuMotionControl.h" />
+    <QtMoc Include="Config\Mapping\WiimoteEmuMotionControlIMU.h" />
+    <ClInclude Include="Config\NewPatchDialog.h" />
+    <ClInclude Include="Config\PatchesWidget.h" />
+    <QtMoc Include="Config\PropertiesDialog.h" />
+    <QtMoc Include="Config\SettingsWindow.h" />
+    <QtMoc Include="Config\VerifyWidget.h" />
+    <QtMoc Include="ConvertDialog.h" />
+    <QtMoc Include="Debugger\BreakpointWidget.h" />
+    <QtMoc Include="Debugger\CodeViewWidget.h" />
+    <QtMoc Include="Debugger\CodeWidget.h" />
+    <QtMoc Include="Debugger\JITWidget.h" />
+    <QtMoc Include="Debugger\MemoryViewWidget.h" />
+    <QtMoc Include="Debugger\MemoryWidget.h" />
+    <QtMoc Include="Debugger\NetworkWidget.h" />
+    <QtMoc Include="Debugger\NewBreakpointDialog.h" />
+    <QtMoc Include="Debugger\PatchInstructionDialog.h" />
+    <QtMoc Include="Debugger\RegisterWidget.h" />
+    <QtMoc Include="Debugger\ThreadWidget.h" />
+    <QtMoc Include="Debugger\WatchWidget.h" />
+    <QtMoc Include="DiscordHandler.h" />
+    <QtMoc Include="DiscordJoinRequestDialog.h" />
+    <QtMoc Include="FIFO\FIFOAnalyzer.h" />
+    <QtMoc Include="FIFO\FIFOPlayerWindow.h" />
+    <QtMoc Include="GameList\GameList.h" />
+    <QtMoc Include="GameList\GameListModel.h" />
+    <QtMoc Include="GameList\GameTracker.h" />
+    <QtMoc Include="GameList\GridProxyModel.h" />
+    <QtMoc Include="GameList\ListProxyModel.h" />
+    <QtMoc Include="GCMemcardCreateNewDialog.h" />
+    <QtMoc Include="GCMemcardManager.h" />
+    <QtMoc Include="Host.h" />
+    <QtMoc Include="HotkeyScheduler.h" />
+    <QtMoc Include="MainWindow.h" />
+    <QtMoc Include="MenuBar.h" />
+    <QtMoc Include="NetPlay\ChunkedProgressDialog.h" />
+    <QtMoc Include="NetPlay\GameListDialog.h" />
+    <QtMoc Include="NetPlay\MD5Dialog.h" />
+    <QtMoc Include="NetPlay\NetPlayBrowser.h" />
+    <QtMoc Include="NetPlay\NetPlayDialog.h" />
+    <QtMoc Include="NetPlay\NetPlaySetupDialog.h" />
+    <QtMoc Include="NetPlay\PadMappingDialog.h" />
+    <QtMoc Include="NKitWarningDialog.h" />
+    <QtMoc Include="QtUtils\AspectRatioWidget.h" />
+    <QtMoc Include="QtUtils\BlockUserInputFilter.h" />
+    <QtMoc Include="QtUtils\DoubleClickEventFilter.h" />
+    <QtMoc Include="QtUtils\ElidedButton.h" />
+    <QtMoc Include="QtUtils\FileOpenEventFilter.h" />
+    <ClInclude Include="QtUtils\FlowLayout.h" />
+    <ClInclude Include="QtUtils\ModalMessageBox.h" />
+    <QtMoc Include="QtUtils\ParallelProgressDialog.h" />
+    <QtMoc Include="QtUtils\UTF8CodePointCountValidator.h" />
+    <QtMoc Include="QtUtils\WindowActivationEventFilter.h" />
+    <ClInclude Include="QtUtils\WrapInScrollArea.h" />
+    <QtMoc Include="RenderWidget.h" />
+    <QtMoc Include="SearchBar.h" />
+    <QtMoc Include="Settings.h" />
+    <QtMoc Include="Settings\AdvancedPane.h" />
+    <QtMoc Include="Settings\AudioPane.h" />
+    <QtMoc Include="Settings\GameCubePane.h" />
+    <QtMoc Include="Settings\GeneralPane.h" />
+    <QtMoc Include="Settings\InterfacePane.h" />
+    <QtMoc Include="Settings\PathPane.h" />
+    <QtMoc Include="Settings\USBDeviceAddToWhitelistDialog.h" />
+    <QtMoc Include="Settings\WiiPane.h" />
+    <QtMoc Include="TAS\GCTASInputWindow.h" />
+    <QtMoc Include="TAS\IRWidget.h" />
+    <QtMoc Include="TAS\StickWidget.h" />
+    <QtMoc Include="TAS\TASCheckBox.h" />
+    <QtMoc Include="TAS\TASInputWindow.h" />
+    <QtMoc Include="TAS\WiiTASInputWindow.h" />
+    <QtMoc Include="ToolBar.h" />
+    <QtMoc Include="Updater.h" />
   </ItemGroup>
   <ItemGroup>
     <Text Include="CMakeLists.txt" />
@@ -531,9 +400,7 @@
     </ProjectReference>
   </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets">
-    <Import Project="$(VSPropsDir)QtCompile.targets" />
-  </ImportGroup>
+  <ImportGroup Label="ExtensionTargets" />
   <!--Copy Exe, Data directory and DLLs which should be located in the executable directory-->
   <ItemGroup>
     <DataSysFiles Include="$(DolphinRootDir)Data\**\Sys\**\*.*" />
diff --git a/Source/VSProps/QtCompile.props b/Source/VSProps/QtCompile.props
index 6ee1546228..107f176795 100644
--- a/Source/VSProps/QtCompile.props
+++ b/Source/VSProps/QtCompile.props
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup Label="UserMacros">
     <QTDIRDefault Condition="'$(Platform)'=='x64'">$(ExternalsDir)Qt\Qt5.15.0\msvc2019_64\</QTDIRDefault>
     <QTDIRDefault Condition="'$(Platform)'=='ARM64'">$(ExternalsDir)Qt\Qt5.15.0\msvc2019_arm64\</QTDIRDefault>
@@ -12,7 +12,6 @@
     <QtBinDir>$(QTDIR)bin\</QtBinDir>
     <QtPluginsDir>$(QTDIR)plugins\</QtPluginsDir>
     <QtToolOutDir>$(IntDir)</QtToolOutDir>
-    <QtMocOutPrefix>$(QtToolOutDir)moc_</QtMocOutPrefix>
     <QtDebugSuffix>d</QtDebugSuffix>
     <QtLibSuffix Condition="'$(Configuration)'=='Debug'">$(QtDebugSuffix)</QtLibSuffix>
     <QtPluginFolder>QtPlugins</QtPluginFolder>
@@ -22,7 +21,6 @@
       <PreprocessorDefinitions Condition="'$(Configuration)'=='Release'">QT_NO_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <PreprocessorDefinitions>QT_DLL;QT_CORE_LIB;QT_GUI_LIB;QT_WIDGETS_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <PreprocessorDefinitions>QT_USE_QSTRINGBUILDER;QT_NO_CAST_FROM_ASCII;QT_NO_CAST_TO_ASCII;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <AdditionalIncludeDirectories>$(ProjectDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <AdditionalIncludeDirectories>$(QtToolOutDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <AdditionalIncludeDirectories>$(QtIncludeDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <AdditionalIncludeDirectories>$(QtIncludeDir)QtCore;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
@@ -45,46 +43,32 @@
     </Link>
   </ItemDefinitionGroup>
 
-  <!--Compile files needed to MOC and output in the build directory-->
-  <!--TODO find a way to autocreate from ClCompile settings-->
-  <PropertyGroup>
-    <MocDefines>-DQT_USE_QSTRINGBUILDER -DQT_NO_CAST_FROM_ASCII -DQT_NO_CAST_TO_ASCII -DQT_DLL -DQT_CORE_LIB -DQT_GUI_LIB -DQT_WIDGETS_LIB -D_SECURE_SCL=0 -D_ARCH_64=1 -D_M_X86_64=1 -D_M_X86=1 -DUSE_UPNP -D_CRT_SECURE_NO_WARNINGS -D_CRT_SECURE_NO_DEPRECATE -D_UNICODE -DUNICODE</MocDefines>
-    <MocDefines Condition="'$(Configuration)'=='Release'">-DQT_NO_DEBUG -DNDEBUG $(MocDefines)</MocDefines>
-    <!-- !!!HOLY UGLY BATMAN!!!
-        Be very careful here when adding include directories. Each path must have the whole arg surrounded by doublequotes - HOWEVER,
-        the ending doublequote cannot be directly preceeded by a directory seperator. In other words, you must use:
-        "-I$(SomeDir) "
-        instead of
-        "-I$(SomeDir)"
-        in order to prevent the trailing slash from escaping the doublequote after value replacement.
-        -->
-    <MocIncludes>"-I$(QtIncludeDir)QtWidgets" "-I$(QtIncludeDir)QtGui" "-I$(QtIncludeDir)QtCore" "-I$(QtIncludeDir) " "-I$(QtToolOutDir) " -I.</MocIncludes>
-    <MocIncludes>"-I$(ExternalsDir)xxhash" "-I$(ExternalsDir)zlib" "-I$(ExternalsDir)SFML\include" "-I$(ExternalsDir)mbedtls\include" "-I$(ExternalsDir)miniupnpc\src" "-I$(ExternalsDir)LZO" "-I$(ExternalsDir)libusbx\libusb" "-I$(ExternalsDir)libpng" "-I$(ExternalsDir)GL" "-I$(ExternalsDir)Bochs_disasm" "-I$(CoreDir) " $(MocIncludes)</MocIncludes>
-  </PropertyGroup>
-  <Target Name="QtMoc"
-    BeforeTargets="ClCompile"
-    Condition="'@(QtMoc)'!=''"
-    Inputs="%(QtMoc.Identity);%(QtMoc.AdditionalDependencies);$(MSBuildProjectFile)"
-    Outputs="$(QtToolOutDir)moc_%(QtMoc.Filename).cpp">
-    <Message Text="moc %(QtMoc.Filename)" Importance="High" />
-    <Error Condition="!$(QtDirValid)" Text="QTDIR not set or non-existent (pull the submodule?)" />
-    <MakeDir Directories="$(QtToolOutDir)" />
-    <Exec Command="&quot;$(QtBinDir)moc.exe&quot; &quot;%(QtMoc.FullPath)&quot; -o &quot;$(QtToolOutDir)moc_%(QtMoc.Filename).cpp&quot; -f%(QtMoc.Filename)%(QtMoc.Extension) $(MocDefines) $(MocIncludes)" />
-  </Target>
-
-  <ItemGroup>
-    <MocOutputs Include="$(QtToolOutDir)moc_*.cpp" />
-  </ItemGroup>
-  <Target Name="QtMocClean">
-    <Delete Files="@(MocOutputs)" />
+  <!--
+    Use the moc implementation provided by "Qt VS Tools"
+    see: https://code.qt.io/cgit/qt-labs/vstools.git/tree/src/qtmsbuild
+    This provides a wrapper around moc which deals with parallel dispatch to moc,
+    as well as creating ClCompile inputs from the moc outputs.
+    Note that we currently pass the same ClCompile.PreprocessorDefinitions to moc,
+    but not the include paths, as passing include paths drastically slows down
+    moc, and it doesn't appear to actually need them anyway.
+  -->
+  <Import Project="qtmoc.props" />
+  <ItemDefinitionGroup>
+    <QtMoc>
+      <OutputFile>$(QtToolOutDir)moc_%(Filename).cpp</OutputFile>
+      <QtMocDir>$(QtToolOutDir)</QtMocDir>
+    </QtMoc>
+  </ItemDefinitionGroup>
+  <Import Project="qt_globals.targets"/>
+  <Import Project="qt_tasks.targets"/>
+  <Import Project="qtmoc.targets" />
+  <Target Name="QtCheckQtDir" BeforeTargets="QtMocInit" Condition="!$(QtDirValid)">
+    <Error Text="QTDIR not set or non-existent (pull the submodule?)" />
   </Target>
 
   <!--Expose the new targets to VS-->
   <ItemGroup>
     <PropertyPageSchema Include="$(MSBuildThisFileDirectory)$(MSBuildThisFileName).xml" />
-    <AvailableItemName Include="QtMoc">
-      <Targets>QtMoc</Targets>
-    </AvailableItemName>
   </ItemGroup>
 
   <!--Copy the needed dlls-->
diff --git a/Source/VSProps/QtCompile.targets b/Source/VSProps/QtCompile.targets
deleted file mode 100644
index bd437e7c34..0000000000
--- a/Source/VSProps/QtCompile.targets
+++ /dev/null
@@ -1,10 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup>
-    <CleanDependsOn>QtMocClean;$(CleanDependsOn)</CleanDependsOn>
-    <!--
-    <ComputeLinkInputsTargets>$(ComputeLinkInputsTargets);QtComputeMocOutput;</ComputeLinkInputsTargets>
-    <ComputeLibInputsTargets>$(ComputeLibInputsTargets);QtComputeMocOutput;</ComputeLibInputsTargets>
-    -->
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/Source/VSProps/qt_globals.targets b/Source/VSProps/qt_globals.targets
new file mode 100644
index 0000000000..8b6eb23dbc
--- /dev/null
+++ b/Source/VSProps/qt_globals.targets
@@ -0,0 +1,558 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/****************************************************************************
+**
+** Copyright (C) 2018 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the Qt VS Tools.
+**
+** $QT_BEGIN_LICENSE:GPL-EXCEPT$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 as published by the Free Software
+** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+-->
+
+<!--
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// Qt/MSBuild global definitions
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// -->
+<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+
+  <!--
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  // Build dependencies
+  // -->
+  <PropertyGroup>
+    <BuildDependsOn>
+      QtVersion;
+      $(BuildDependsOn);
+      Qt
+    </BuildDependsOn>
+    <CleanDependsOn>
+      $(CleanDependsOn);
+      QtClean
+    </CleanDependsOn>
+    <DesignTimeBuildInitTargets>
+      $(DesignTimeBuildInitTargets);
+      Qt
+    </DesignTimeBuildInitTargets>
+    <ComputeCompileInputsTargets>
+      $(ComputeCompileInputsTargets);
+      Qt
+    </ComputeCompileInputsTargets>
+    <BeforeClCompileTargets>
+      $(BeforeClCompileTargets);
+      Qt
+    </BeforeClCompileTargets>
+    <ComputeLinkInputsTargets>
+      $(ComputeLinkInputsTargets);
+      Qt
+    </ComputeLinkInputsTargets>
+  </PropertyGroup>
+
+  <!--
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  // Qt/MSBuild global properties
+  // -->
+  <Import Project="..\version.targets" Condition="Exists('..\version.targets')"/>
+  <PropertyGroup>
+    <QtMsBuildVersion>$(QtVSToolsVersion)</QtMsBuildVersion>
+    <QtDebug Condition="'$(QtDebug)' == ''">false</QtDebug>
+    <QtLogFilePath Condition="'$(QtLogFilePath)' == ''"
+      >$([System.IO.Path]::Combine($(ProjectDir),$(IntDir)qt_work.log))</QtLogFilePath>
+    <QtMaxProcs Condition="'$(QtMaxProcs)' == ''"
+      >$([System.Environment]::ProcessorCount)</QtMaxProcs>
+  </PropertyGroup>
+
+  <!--
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  /// TARGET QtGetDefaultClCompile
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  // Get default C++ properties
+  // -->
+  <Target Name="QtGetDefaultClCompile">
+    <ItemGroup>
+      <ClCompile Include="DefaultClCompile"/>
+    </ItemGroup>
+  </Target>
+
+  <!--
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  /// TARGET QtClean
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  // Clean-up from previous build
+  // -->
+  <Target Name="QtClean">
+    <Message Importance="High" Condition="'$(QtDebug)' == 'true'" Text="## Qt Clean"/>
+    <Delete Files="$(QtLogFilePath)"/>
+  </Target>
+
+  <!--
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  /// TARGET QtVersion
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  // Print debug message with Qt/MSBuild version
+  // -->
+  <Target Name="QtVersion">
+    <Message Importance="High" Condition="'$(QtDebug)' == 'true'"
+      Text="Qt/MSBuild v$(QtMsBuildVersion) ($(MSBuildThisFileDirectory))"/>
+  </Target>
+
+  <!--
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  /// TARGET QtPrepare
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  // Prepare Qt build: read and parse work log file
+  // -->
+  <Target Name="QtPrepare"
+    Condition="'$(QtSkipWork)' != 'true'"
+    DependsOnTargets="$(QtDependsOn)"
+    BeforeTargets="QtWorkPrepare">
+
+    <Message Importance="High" Condition="'$(QtDebug)' == 'true'" Text="#### QtPrepare"/>
+
+    <ReadLinesFromFile File="$(QtLogFilePath)">
+      <Output TaskParameter="Lines" ItemName="QtLogData"/>
+    </ReadLinesFromFile>
+    <ItemGroup Condition="'@(QtLogData)' != ''">
+      <QtWorkLog
+        Include="@(QtLogData->'$([System.String]::Copy('%(QtLogData.Identity)').Split('|')[0])')">
+        <Hash>$([System.String]::Copy('%(QtLogData.Identity)').Split('|')[1])</Hash>
+      </QtWorkLog>
+    </ItemGroup>
+  </Target>
+
+  <!--
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  /// TARGET QtWorkPrepare
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  // Analyze work request and decide if the Qt tool needs to be called or if the output from the
+  // previous call is still valid.
+  // -->
+  <Target Name="QtWorkPrepare" DependsOnTargets="$(QtDependsOn);$(QtBuildTargets)"
+    Condition="'$(QtSkipWork)' != 'true'"
+    Inputs="%(QtWork.WorkType)(%(QtWork.Identity))"
+    Outputs="@(QtWork->'####### Don't skip this target #######')">
+
+    <Message Importance="High" Condition="'$(QtDebug)' == 'true' AND '@(QtWork)' != ''"
+      Text="## QtWorkPrepare %(QtWork.Identity)" />
+
+    <!--
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    // Calculate hash for the requested work item, based on its associated tool and options
+    // -->
+    <GetItemHash Condition="'@(QtWork)' != ''"
+      Item="@(QtWork)" Keys="Identity;WorkType;ToolPath;Options">
+      <Output TaskParameter="Hash" PropertyName="work_hash" />
+    </GetItemHash>
+
+    <!--
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    // Try to find entry in Qt work log for the requested work item; get logged hash
+    // -->
+    <PropertyGroup Condition="'@(QtWork)' != ''">
+      <work_key>@(QtWork->'%(WorkType)(%(Identity))')</work_key>
+      <dependencies_changed>@(QtWork->'%(DependenciesChanged)')</dependencies_changed>
+      <input_changed>@(QtWork->'%(InputChanged)')</input_changed>
+      <project_changed
+        Condition="'$(dependencies_changed)' == 'true' AND '$(input_changed)' != 'true'"
+        >true</project_changed>
+    </PropertyGroup>
+
+    <FindInList Condition="'@(QtWork)' != '' AND '$(input_changed)' != 'true'"
+      CaseSensitive="false" List="@(QtWorkLog)" ItemSpecToFind="$(work_key)">
+      <Output TaskParameter="ItemFound" ItemName="log_entry"/>
+    </FindInList>
+
+    <PropertyGroup Condition="'@(QtWork)' != ''">
+      <log_hash Condition="'@(log_entry)' != ''">@(log_entry->'%(Hash)')</log_hash>
+    </PropertyGroup>
+
+    <!--
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    // Skip work item if:
+    //  * work is not needed:
+    //      - input was not modified
+    //      - AND project was not modified OR command line did not change (i.e. hashes are the same)
+    //  * OR we're in a design-time build
+    // -->
+    <PropertyGroup>
+      <do_work
+        Condition="'$(input_changed)' == 'true'
+               OR ('$(project_changed)' == 'true' AND '$(log_hash)' != '$(work_hash)')"
+        >true</do_work>
+      <skip_work
+        Condition="'$(do_work)' != 'true' OR '$(DesignTimeBuild)' == 'true'"
+        >true</skip_work>
+    </PropertyGroup>
+
+    <!--
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    // Skip work item
+    // -->
+    <ItemGroup Condition="'@(QtWork)' != '' AND '$(skip_work)' == 'true'">
+      <QtWorkResult Include="@(QtWork)">
+        <ExitCode>0</ExitCode>
+        <Skipped>true</Skipped>
+      </QtWorkResult>
+      <QtWork Remove="@(QtWork)" />
+    </ItemGroup>
+
+    <!--
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    // Generate new work log entry and ensure path to output exists
+    // -->
+    <ItemGroup Condition="'@(QtWork)' != '' AND '$(skip_work)' != 'true'">
+      <QtWorkLog Remove="$(work_key)"/>
+      <QtWorkLog Include="$(work_key)">
+        <Hash>$(work_hash)</Hash>
+      </QtWorkLog>
+    </ItemGroup>
+
+    <MakeDir Condition="'@(QtWork)' != '' AND '$(skip_work)' != 'true'"
+      Directories="$([System.IO.Path]::GetDirectoryName(%(QtWork.OutputFile)))"/>
+
+    <!--
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    // Clean-up
+    // -->
+    <PropertyGroup>
+      <work_key/>
+      <log_hash/>
+      <dependencies_changed/>
+      <input_changed/>
+      <project_changed/>
+      <do_work/>
+      <skip_work/>
+    </PropertyGroup>
+    <ItemGroup>
+      <log_entry Remove="@(log_entry)"/>
+    </ItemGroup>
+  </Target>
+
+  <!--
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  /// TARGET QtWork
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  // Run Qt tools and add dynamic C++ sources to build
+  // -->
+  <Target Name="QtWork"
+    Condition="'$(QtSkipWork)' != 'true'"
+    DependsOnTargets="QtWorkPrepare;QtGetDefaultClCompile">
+
+    <Message Importance="High" Condition="'$(QtDebug)' == 'true'"
+      Text="## Qt Build $(QtBuildTargets.Replace(';',' ').Trim())" />
+
+    <!--
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    // Run work locally in parallel processes
+    // -->
+    <QtRunWork
+      Condition="'$(ApplicationType)' != 'Linux' AND '@(QtWork)' != ''
+        AND '%(QtWork.ParallelBuild)' == 'true'
+        AND '$(DesignTimeBuild)' != 'true'"
+      QtWork="@(QtWork)" QtMaxProcs="$(QtMaxProcs)" QtDebug="$(QtDebug)">
+      <Output TaskParameter="Result" ItemName="QtWorkResult" />
+    </QtRunWork>
+
+    <!--
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    // Run work locally in a single process
+    // -->
+    <QtRunWork
+      Condition="'$(ApplicationType)' != 'Linux' AND '@(QtWork)' != ''
+        AND '%(QtWork.ParallelBuild)' != 'true'
+        AND '$(DesignTimeBuild)' != 'true'"
+      QtWork="@(QtWork)" QtMaxProcs="1" QtDebug="$(QtDebug)">
+      <Output TaskParameter="Result" ItemName="QtWorkResult" />
+    </QtRunWork>
+
+    <!--
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    // Run work in build host
+    // -->
+    <!-- // Translate local paths to host paths -->
+    <Flatten
+      Condition="'$(ApplicationType)' == 'Linux'
+        AND '@(QtWork)' != '' AND '$(DesignTimeBuild)' != 'true'"
+      Items="@(QtWork)" Metadata="ResourceFiles">
+      <Output TaskParameter="Result" ItemName="ResourceFiles"/>
+    </Flatten>
+    <ItemGroup
+      Condition="'$(ApplicationType)' == 'Linux'
+        AND '@(QtWork)' != '' AND '$(DesignTimeBuild)' != 'true'">
+      <LocalPath Include="%(QtWork.Identity)">
+        <Name>InputPath</Name>
+        <Item>%(QtWork.Identity)</Item>
+        <Value>%(QtWork.Identity)</Value>
+      </LocalPath>
+      <LocalPath
+        Condition="'%(ResourceFiles.Identity)' != ''"
+        Include="@(ResourceFiles->'%(Item)')">
+        <Name>InputPath</Name>
+        <Item>@(ResourceFiles->'%(Value)')</Item>
+        <Value>@(ResourceFiles->'%(Value)')</Value>
+      </LocalPath>
+      <LocalPath Include="%(QtWork.Identity)">
+        <Name>OutputPath</Name>
+        <Item>%(QtWork.OutputFile)</Item>
+        <Value>%(QtWork.OutputFile)</Value>
+      </LocalPath>
+    </ItemGroup>
+    <HostTranslatePaths
+      Condition="'$(ApplicationType)' == 'Linux'
+        AND '@(QtWork)' != '' AND '$(DesignTimeBuild)' != 'true'"
+      Items="@(LocalPath)" Names="InputPath;OutputPath">
+      <Output TaskParameter="Result" ItemName="HostPath"/>
+    </HostTranslatePaths>
+    <ItemGroup>
+      <InputPath Include="@(HostPath->WithMetadataValue('Name', 'InputPath'))" />
+      <OutputPath Include="@(HostPath->WithMetadataValue('Name', 'OutputPath'))" />
+    </ItemGroup>
+
+    <!-- // Run command -->
+    <HostExec
+      Condition="'$(ApplicationType)' == 'Linux'
+        AND '%(Identity)' != '' AND '$(DesignTimeBuild)' != 'true'"
+      Message="@(QtWork->'%(WorkType) %(Identity)')"
+      Command="@(QtWork->'%(ToolPath) %(Options)')"
+      Inputs="@(InputPath)"
+      Outputs="@(OutputPath)"
+      RemoteTarget="$(ResolvedRemoteTarget)"
+      RemoteProjectDir="$(_ResolvedRemoteProjectDir)">
+    </HostExec>
+
+    <!-- // Generate result item -->
+    <ItemGroup
+      Condition="'$(ApplicationType)' == 'Linux'
+        AND '@(QtWork)' != '' AND '$(DesignTimeBuild)' != 'true'">
+      <QtWorkResult Include="@(QtWork)">
+        <ExitCode>0</ExitCode>
+      </QtWorkResult>
+    </ItemGroup>
+
+    <!--
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    // Save tracking log of files read during build; used by VS to check the up-to-date status
+    // -->
+    <ItemGroup Condition="'$(DesignTimeBuild)' != 'true'">
+      <read_log Include="^%(QtWorkResult.FullPath);%(QtWorkResult.AdditionalDependencies)"
+        Condition="'%(QtWorkResult.ExitCode)' == '0' AND '%(QtWorkResult.DisableLog)' != 'true'">
+        <WorkType>%(QtWorkResult.WorkType)</WorkType>
+      </read_log>
+      <read_log>
+        <Path Condition="$([System.String]::Copy('%(Identity)').StartsWith('^'))">%(Identity)</Path>
+        <Path Condition="!$([System.String]::Copy('%(Identity)').StartsWith('^'))"
+          >$([System.IO.Path]::Combine('$(MSBuildProjectDirectory)','%(Identity)'))</Path>
+      </read_log>
+    </ItemGroup>
+
+    <WriteLinesToFile
+      Condition="'@(read_log)' != ''"
+      File="$(TLogLocation)%(read_log.WorkType).read.1u.tlog"
+      Lines="@(read_log->MetaData('Path')->ToUpperInvariant());"
+      Overwrite="true"
+      Encoding="Unicode"/>
+
+    <!--
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    // Save tracking log of files written during build; used by VS to check the up-to-date status
+    // -->
+    <ItemGroup Condition="'$(DesignTimeBuild)' != 'true'">
+      <write_log Include="^%(QtWorkResult.FullPath);%(QtWorkResult.OutputFile)"
+        Condition="'%(QtWorkResult.ExitCode)' == '0' AND '%(QtWorkResult.DisableLog)' != 'true'">
+        <WorkType>%(QtWorkResult.WorkType)</WorkType>
+      </write_log>
+      <write_log>
+        <Path Condition="$([System.String]::Copy('%(Identity)').StartsWith('^'))">%(Identity)</Path>
+        <Path Condition="!$([System.String]::Copy('%(Identity)').StartsWith('^'))"
+          >$([System.IO.Path]::Combine('$(MSBuildProjectDirectory)','%(Identity)'))</Path>
+      </write_log>
+    </ItemGroup>
+
+    <WriteLinesToFile Condition="'@(write_log)' != ''"
+     File="$(TLogLocation)%(write_log.WorkType).write.1u.tlog"
+     Lines="@(write_log->MetaData('Path')->ToUpperInvariant());"
+     Overwrite="true" Encoding="Unicode"/>
+
+    <!--
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    // Log output files; this is used by VS to determine what files to delete on "Clean"
+    // -->
+    <ItemGroup Condition="'$(DesignTimeBuild)' != 'true'">
+      <clean_log Include="%(QtWorkResult.OutputFile)"
+        Condition="'%(QtWorkResult.ExitCode)' == '0'">
+        <Source>@(QtWorkResult, '|')</Source>
+      </clean_log>
+    </ItemGroup>
+
+    <WriteLinesToFile Condition="'@(clean_log)' != ''"
+      File="$(TLogLocation)$(ProjectName).write.1u.tlog"
+      Lines="^%(clean_log.Source);@(clean_log->'%(Fullpath)')"
+      Encoding="Unicode"/>
+
+    <!--
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    // Log calls to Qt tools; used in QtWorkPrepare to detect changes to the options of Qt tools
+    // -->
+    <WriteLinesToFile Condition="'@(QtWorkLog)' != '' AND '$(DesignTimeBuild)' != 'true'"
+      File="$(QtLogFilePath)"
+      Lines="@(QtWorkLog->'%(Identity)|%(Hash)')"
+      Overwrite="true" Encoding="Unicode"/>
+
+    <!--
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    // Generate build error if a Qt tool did not terminate correctly
+    // -->
+    <Error
+      Condition="'%(QtWorkResult.ExitCode)' != ''
+        AND '%(QtWorkResult.ExitCode)' != '0'
+        AND '$(DesignTimeBuild)' != 'true'"
+      File="%(QtWorkResult.Identity)" Code="%(QtWorkResult.ExitCode)"
+      Text="%(QtWorkResult.WorkType) (%(QtWorkResult.ToolPath))"/>
+
+    <!--
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    // Add dynamic C++ sources to build
+    // -->
+    <ItemGroup>
+      <QtWork_ClCompile
+        Condition="'%(QtWorkResult.ExitCode)' == '0' AND '%(QtWorkResult.ClCompile)' != ''"
+        Include="@(QtWorkResult->'%(ClCompile)')"/>
+      <QtWork_ClCompile
+        Condition="Exists('$(QtVarsOutputDir)\qtvars_plugin_import.cpp')"
+        Include="$(QtVarsOutputDir)\qtvars_plugin_import.cpp"/>
+    </ItemGroup>
+    <ItemGroup Condition="'$(ApplicationType)' == 'Linux'">
+      <QtWork_ClCompile Condition="'%(QtWork_ClCompile.ObjectFileName)' == ''">
+        <ObjectFileName>$(IntDir)%(Filename).o</ObjectFileName>
+      </QtWork_ClCompile>
+    </ItemGroup>
+
+    <!-- // Copy default C++ compiler properties -->
+    <Expand Condition="'@(QtWork_ClCompile)' != ''"
+      Items="@(QtWork_ClCompile)"
+      BaseItem="@(ClCompile->WithMetadataValue('Identity', 'DefaultClCompile'))">
+      <Output TaskParameter="Result" ItemName="QtWork_ClCompile_Expanded"/>
+    </Expand>
+
+    <!-- // Force pre-compiled header include -->
+    <ItemGroup Condition="'$(ApplicationType)' != 'Linux'">
+      <QtWork_ClCompile_Expanded>
+        <AdditionalIncludeDirectories
+          >$(ProjectDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+        <ForcedIncludeFiles Condition="'%(PrecompiledHeader)' == 'Use'"
+          >%(PrecompiledHeaderFile)</ForcedIncludeFiles>
+      </QtWork_ClCompile_Expanded>
+    </ItemGroup>
+
+    <!-- // Add C++ source items and clean-up temp items -->
+    <ItemGroup>
+      <ClCompile Include="@(QtWork_ClCompile_Expanded)"/>
+      <QtWork_ClCompile_Expanded Remove="@(QtWork_ClCompile_Expanded)"/>
+      <QtWork_ClCompile Remove="@(QtWork_ClCompile)"/>
+    </ItemGroup>
+
+    <!--// If sources were manually selected (e.g. by the 'Compile' option in the context menu for
+        // project items), add generated C++ sources to the list of selected files -->
+    <PropertyGroup Condition="'$(SelectedFiles)' != ''">
+      <SelectedClCompile>@(QtWorkResult->'%(ClCompile)')</SelectedClCompile>
+    </PropertyGroup>
+    <PropertyGroup Condition="'$(SelectedClCompile)' != ''">
+      <SelectedFiles>$(SelectedFiles);$(SelectedClCompile)</SelectedFiles>
+    </PropertyGroup>
+    <ItemGroup Condition="'$(SelectedClCompile)' != ''">
+      <SelectedFiles Include="$(SelectedClCompile)"/>
+    </ItemGroup>
+
+    <!--
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    // Update C++ sources with generated information
+    // -->
+    <PropertyGroup>
+      <QtIncludePath>@(QtIncludePath->Distinct())</QtIncludePath>
+    </PropertyGroup>
+    <ItemGroup>
+      <ClCompile_Updated Include="@(ClCompile)">
+        <AdditionalIncludeDirectories
+>$(QtIncludePath);%(ClCompile.AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      </ClCompile_Updated>
+      <ClCompile Remove="@(ClCompile)"/>
+      <ClCompile Include="@(ClCompile_Updated)"/>
+      <ClCompile_Updated Remove="@(ClCompile_Updated)"/>
+    </ItemGroup>
+
+    <!--
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    // Clean-up
+    // -->
+    <ItemGroup>
+      <QtWork       Remove="@(QtWork)"/>
+      <QtWorkResult Remove="@(QtWorkResult)"/>
+      <QtWorkLog    Remove="@(QtWorkLog)"/>
+      <read_log     Remove="@(read_log)"/>
+      <write_log    Remove="@(write_log)"/>
+      <clean_log    Remove="@(clean_log)"/>
+    </ItemGroup>
+  </Target>
+
+  <!--
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  /// TARGET Qt
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  // Root Qt target
+  // -->
+  <Target Name="Qt" DependsOnTargets="QtPrepare;QtWork" BeforeTargets="FixupCLCompileOptions">
+    <ItemGroup>
+      <ClCompile Remove="DefaultClCompile" />
+    </ItemGroup>
+  </Target>
+
+  <!--
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  /// TARGET QtOuterBuild
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  // Run targets in $(QtOuterBuildDependsOn) and then recursively invoke build
+  // -->
+  <Target Name="QtOuterBuild" DependsOnTargets="$(QtOuterBuildDependsOn)">
+    <!--// Invoke inner build: recursive build in second MSBuild instance -->
+    <MSBuild
+      Projects="$(MSBuildProjectFullPath)"
+      Targets="Build"
+      Properties="QtInnerBuild=$(MSBuildProjectFullPath);RandomFileName=$(RandomFileName)">
+    </MSBuild>
+  </Target>
+
+  <PropertyGroup
+    Condition="'$(QtInnerBuild)' == '' AND '$(DesignTimeBuild)' != 'true'">
+    <!--// Outer build: invoke inner build -->
+    <BuildDependsOn>$(QtOuterBuildPrepare);QtOuterBuild;$(QtOuterBuildFinalize)</BuildDependsOn>
+    <QtInnerBuild>$(MSBuildProjectFullPath)</QtInnerBuild>
+    <RandomFileName>$([System.IO.Path]::GetRandomFileName())</RandomFileName>
+  </PropertyGroup>
+
+  <PropertyGroup
+    Condition="'$(QtInnerBuild)' != '$(MSBuildProjectFullPath)' AND '$(DesignTimeBuild)' != 'true'">
+    <!--// Dependent project inner build: skip build -->
+    <BuildDependsOn>$(QtOuterBuildPrepare);$(QtOuterBuildFinalize)</BuildDependsOn>
+  </PropertyGroup>
+
+</Project>
diff --git a/Source/VSProps/qt_tasks.targets b/Source/VSProps/qt_tasks.targets
new file mode 100644
index 0000000000..7f4a8e155e
--- /dev/null
+++ b/Source/VSProps/qt_tasks.targets
@@ -0,0 +1,1110 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/****************************************************************************
+**
+** Copyright (C) 2018 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the Qt VS Tools.
+**
+** $QT_BEGIN_LICENSE:GPL-EXCEPT$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 as published by the Free Software
+** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+-->
+
+<!--
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Helper inline tasks used by the Qt/MSBuild targets
+// -->
+<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+
+  <!--
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  /// TASK ListQrc
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  // List resource paths in a QRC file.
+  // Parameters:
+  //      in string    QrcFilePath: path to QRC file
+  //     out string[]  Result: paths to files referenced in QRC
+  // -->
+  <UsingTask TaskName="ListQrc"
+    TaskFactory="CodeTaskFactory"
+    AssemblyFile="$(MSBuildToolsPath)\Microsoft.Build.Tasks.Core.dll">
+    <ParameterGroup>
+      <QrcFilePath ParameterType="System.String"   Required="true" />
+      <Result      ParameterType="System.String[]" Output="true" />
+    </ParameterGroup>
+    <Task>
+      <Reference Include="System.Xml"/>
+      <Reference Include="System.Xml.Linq"/>
+      <Using Namespace="System.Xml.Linq"/>
+      <Code Type="Fragment" Language="cs">
+        <![CDATA[
+            XDocument qrc = XDocument.Load(QrcFilePath, LoadOptions.SetLineInfo);
+            IEnumerable<XElement> files = qrc
+                .Element("RCC")
+                .Elements("qresource")
+                .Elements("file");
+            Uri QrcPath = new Uri(QrcFilePath);
+            Result = files
+                .Select(x => new Uri(QrcPath, x.Value).LocalPath)
+                .ToArray();
+        ]]>
+      </Code>
+    </Task>
+  </UsingTask>
+
+  <!--
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  /// TASK GetItemHash
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  // Calculate an hash code (Deflate + Base64) for an item, given a list of metadata to use as key
+  // Parameters:
+  //      in ITaskItem Item: item for which the hash will be calculated
+  //      in string[]  Keys: list of names of the metadata to use as item key
+  //     out string    Hash: hash code (Base64 representation of Deflate'd UTF-8 item key)
+  // -->
+  <UsingTask TaskName="GetItemHash"
+    TaskFactory="CodeTaskFactory" AssemblyFile="$(MSBuildToolsPath)\Microsoft.Build.Tasks.v4.0.dll">
+    <ParameterGroup>
+      <Item               ParameterType="Microsoft.Build.Framework.ITaskItem" Required="true" />
+      <Keys               ParameterType="System.String[]"                     Required="true" />
+      <Hash Output="true" ParameterType="System.String" />
+    </ParameterGroup>
+    <Task>
+      <Using Namespace="System"/>
+      <Using Namespace="System.Text"/>
+      <Using Namespace="System.IO"/>
+      <Using Namespace="System.IO.Compression"/>
+      <Code Type="Fragment" Language="cs">
+        <![CDATA[
+            var data = Encoding.UTF8.GetBytes(string.Concat(Keys.OrderBy(x => x)
+                .Select(x => string.Format("[{0}={1}]", x, Item.GetMetadata(x))))
+                .ToUpper());
+            using (var dataZipped = new MemoryStream()) {
+                using (var zip = new DeflateStream(dataZipped, CompressionLevel.Fastest))
+                    zip.Write(data, 0, data.Length);
+                Hash = Convert.ToBase64String(dataZipped.ToArray());
+            }
+        ]]>
+      </Code>
+    </Task>
+  </UsingTask>
+
+  <!--
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  /// TASK Expand
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  // Expand a list of items, taking additional metadata from a base item and from a template item.
+  // Parameters:
+  //      in ITaskItem[] Items:    items to expand
+  //      in ITaskItem   BaseItem: base item from which the expanded items derive
+  //      in ITaskItem   Template = null: (optional) template containing metadata to add / update
+  //     out ITaskItem[] Result:   list of new items
+  // -->
+  <UsingTask TaskName="Expand"
+    TaskFactory="CodeTaskFactory" AssemblyFile="$(MSBuildToolsPath)\Microsoft.Build.Tasks.v4.0.dll">
+    <ParameterGroup>
+      <Items                ParameterType="Microsoft.Build.Framework.ITaskItem[]" Required="true" />
+      <BaseItem             ParameterType="Microsoft.Build.Framework.ITaskItem"   Required="true" />
+      <Template             ParameterType="Microsoft.Build.Framework.ITaskItem"   Required="false"/>
+      <Result Output="true" ParameterType="Microsoft.Build.Framework.ITaskItem[]" />
+    </ParameterGroup>
+    <Task>
+      <Using Namespace="System"/>
+      <Using Namespace="System.Text.RegularExpressions"/>
+      <Code Type="Fragment" Language="cs">
+        <![CDATA[
+            Result = new ITaskItem[] { };
+            var reserved = new HashSet<string>(StringComparer.InvariantCultureIgnoreCase)
+            {
+                "AccessedTime", "CreatedTime", "DefiningProjectDirectory",
+                "DefiningProjectExtension", "DefiningProjectFullPath", "DefiningProjectName",
+                "Directory", "Extension", "Filename", "FullPath", "Identity", "ModifiedTime",
+                "RecursiveDir", "RelativeDir", "RootDir",
+            };
+            var newItems = new List<ITaskItem>();
+            foreach (var item in Items) {
+                var newItem = new TaskItem(item);
+                if (BaseItem != null)
+                    BaseItem.CopyMetadataTo(newItem);
+                var itemExt = newItem.GetMetadata("Extension");
+                if (!string.IsNullOrEmpty(itemExt))
+                    newItem.SetMetadata("Suffix", itemExt.Substring(1));
+                if (Template != null) {
+                    var metadataNames = Template.MetadataNames
+                        .Cast<string>().Where(x => !reserved.Contains(x));
+                    foreach (var metadataName in metadataNames) {
+                        var metadataValue = Template.GetMetadata(metadataName);
+                        newItem.SetMetadata(metadataName,
+                            Regex.Replace(metadataValue, @"(%<)(\w+)(>)",
+                            match => newItem.GetMetadata(match.Groups[2].Value)));
+                    }
+                }
+                newItems.Add(newItem);
+            }
+            Result = newItems.ToArray();
+        ]]>
+      </Code>
+    </Task>
+  </UsingTask>
+
+  <!--
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  /// TASK DumpItems
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  // Dump contents of items as a log message. The contents are formatted as XML.
+  // Parameters:
+  //      in string       ItemType:     type of the items; this is used as the parent node of each
+  //                                    item dump
+  //      in ITaskItem[]  Items:        items to dump
+  //      in bool         DumpReserved: include MSBuild reserved metadata in dump?
+  //      in string       Metadata:     list of names of metadata to include in dump; omit to
+  //                                    include all metadata
+  // -->
+  <UsingTask TaskName="DumpItems"
+    TaskFactory="CodeTaskFactory" AssemblyFile="$(MSBuildToolsPath)\Microsoft.Build.Tasks.v4.0.dll">
+    <ParameterGroup>
+      <ItemType     ParameterType="System.String"                         Required="true" />
+      <Items        ParameterType="Microsoft.Build.Framework.ITaskItem[]" Required="true" />
+      <DumpReserved ParameterType="System.Boolean"                        Required="false" />
+      <Metadata     ParameterType="System.String"                         Required="false" />
+    </ParameterGroup>
+    <Task>
+      <Using Namespace="System"/>
+      <Using Namespace="System.Diagnostics"/>
+      <Using Namespace="System.Text"/>
+      <Code Type="Fragment" Language="cs">
+        <![CDATA[
+            var reserved = new HashSet<string>
+            {
+                "AccessedTime", "CreatedTime", "DefiningProjectDirectory",
+                "DefiningProjectExtension", "DefiningProjectFullPath", "DefiningProjectName",
+                "Directory", "Extension", "Filename", "FullPath", "Identity", "ModifiedTime",
+                "RecursiveDir", "RelativeDir", "RootDir",
+            };
+            if (Metadata == null)
+                Metadata = "";
+            var requestedNames = new HashSet<string>(Metadata.Split(new[] { ';' },
+                StringSplitOptions.RemoveEmptyEntries));
+            var itemXml = new StringBuilder();
+            if (Items.Any()) {
+                foreach (var item in Items) {
+                    if (itemXml.Length > 0)
+                        itemXml.Append("\r\n");
+                    itemXml.AppendFormat("<{0} Include=\"{1}\"", ItemType, item.ItemSpec);
+                    var names = item.MetadataNames.Cast<string>()
+                        .Where(x => (DumpReserved || !reserved.Contains(x))
+                        && (!requestedNames.Any() || requestedNames.Contains(x)))
+                        .OrderBy(x => x);
+                    if (names.Any()) {
+                        itemXml.Append(">\r\n");
+                        foreach (string name in names) {
+                            if (!DumpReserved && reserved.Contains(name))
+                                continue;
+                            if (!item.MetadataNames.Cast<string>().Contains(name))
+                                continue;
+                            var value = item.GetMetadata(name);
+                            if (!string.IsNullOrEmpty(value))
+                                itemXml.AppendFormat("  <{0}>{1}</{0}>\r\n", name, value);
+                            else
+                                itemXml.AppendFormat("  <{0}/>\r\n", name);
+                        }
+                        itemXml.AppendFormat("</{0}>", ItemType);
+                    } else {
+                        itemXml.Append("/>");
+                    }
+                }
+            } else {
+                itemXml.AppendFormat("<{0}/>", ItemType);
+            }
+            Log.LogMessage(MessageImportance.High, itemXml.ToString());
+        ]]>
+      </Code>
+    </Task>
+  </UsingTask>
+
+  <!--
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  /// TASK QtRunWork
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  // Run work items in parallel processes.
+  // Parameters:
+  //      in ITaskItem[] QtWork:      work items
+  //      in int         QtMaxProcs:  maximum number of processes to run in parallel
+  //      in bool        QtDebug:     generate debug messages
+  //     out ITaskItem[] Result:      list of new items with the result of each work item
+  // -->
+  <UsingTask
+    TaskName="QtRunWork"
+    TaskFactory="CodeTaskFactory"
+    AssemblyFile="$(MSBuildToolsPath)\Microsoft.Build.Tasks.v4.0.dll">
+    <ParameterGroup>
+      <QtWork               ParameterType="Microsoft.Build.Framework.ITaskItem[]" Required="true" />
+      <QtMaxProcs           ParameterType="System.Int32"                          Required="true" />
+      <QtDebug              ParameterType="System.Boolean"                        Required="true" />
+      <Result Output="true" ParameterType="Microsoft.Build.Framework.ITaskItem[]" />
+    </ParameterGroup>
+    <Task>
+      <Using Namespace="System"/>
+      <Using Namespace="System.IO"/>
+      <Using Namespace="System.Diagnostics"/>
+      <Using Namespace="System.Collections.Generic"/>
+      <Code Type="Fragment" Language="cs">
+        <![CDATA[
+            Result = new ITaskItem[] { };
+            bool ok = true;
+            var Comparer = StringComparer.InvariantCultureIgnoreCase;
+            var Comparison = StringComparison.InvariantCultureIgnoreCase;
+
+            // Work item key = "%(WorkType)(%(Identity))"
+            Func<string, string, string> KeyString = (x, y) => string.Format("{0}{{{1}}}", x, y);
+            Func<ITaskItem, string> Key = (item) =>
+                KeyString(item.GetMetadata("WorkType"), item.ItemSpec);
+            var workItemKeys = new HashSet<string>(QtWork.Select(x => Key(x)), Comparer);
+
+            // Work items, indexed by %(Identity)
+            var workItemsByIdentity = QtWork
+                .GroupBy(x => x.ItemSpec, x => Key(x), Comparer)
+                .ToDictionary(x => x.Key, x => new List<string>(x), Comparer);
+
+            // Work items, indexed by work item key
+            var workItems = QtWork.Select(x => new
+            {
+                Self = x,
+                Key = Key(x),
+                ToolPath = x.GetMetadata("ToolPath"),
+                Message = x.GetMetadata("Message"),
+                DependsOn = new HashSet<string>(comparer: Comparer,
+                    collection: x.GetMetadata("DependsOn")
+                        .Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries)
+                        .Where(y => workItemsByIdentity.ContainsKey(y))
+                        .SelectMany(y => workItemsByIdentity[y])
+                    .Union(x.GetMetadata("DependsOnWork")
+                        .Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries)
+                        .Select(y => KeyString(y, x.ItemSpec))
+                        .Where(y => workItemKeys.Contains(y)))
+                    .GroupBy(y => y, Comparer).Select(y => y.Key)
+                    .Where(y => !y.Equals(Key(x), Comparison))),
+                ProcessStartInfo = new ProcessStartInfo
+                {
+                    FileName = x.GetMetadata("ToolPath"),
+                    Arguments = x.GetMetadata("Options"),
+                    CreateNoWindow = true,
+                    UseShellExecute = false,
+                    RedirectStandardError = true,
+                    RedirectStandardOutput = true,
+                },
+            })
+            // In case of items with duplicate keys, use only the first one
+            .GroupBy(x => x.Key, Comparer)
+            .ToDictionary(x => x.Key, x => x.First(), Comparer);
+
+            // Result
+            var result = workItems.Values
+                .ToDictionary(x => x.Key, x => new TaskItem(x.Self));
+
+            // Dependency relation [item -> dependent items]
+            var dependentsOf = workItems.Values
+                .Where(x => x.DependsOn.Any())
+                .SelectMany(x => x.DependsOn.Select(y => new { Dependent = x.Key, Dependency = y }))
+                .GroupBy(x => x.Dependency, x => x.Dependent, Comparer)
+                .ToDictionary(x => x.Key, x => new List<string>(x), Comparer);
+
+            // Work items that are ready to start; initially queue all independent items
+            var workQueue = new Queue<string>(workItems.Values
+                .Where(x => !x.DependsOn.Any())
+                .Select(x => x.Key));
+
+            if (QtDebug) {
+                Log.LogMessage(MessageImportance.High,
+                    string.Format("## QtRunWork queueing\r\n##    {0}",
+                    string.Join("\r\n##    ", workQueue)));
+            }
+
+            // Postponed items; save dependent items to queue later when ready
+            var postponedItems = new HashSet<string>(workItems.Values
+                .Where(x => x.DependsOn.Any())
+                .Select(x => x.Key));
+
+            if (QtDebug && postponedItems.Any()) {
+                Log.LogMessage(MessageImportance.High,
+                    string.Format("## QtRunWork postponed dependents\r\n##    {0}",
+                    string.Join("\r\n##    ", postponedItems
+                        .Select(x => string.Format("{0} <- {1}", x,
+                                     string.Join(", ", workItems[x].DependsOn))))));
+            }
+
+            // Work items that are running; must synchronize with the exit of all processes
+            var running = new Queue<KeyValuePair<string, Process>>();
+
+            // Work items that have terminated
+            var terminated = new HashSet<string>(Comparer);
+
+            // While there are work items queued, start a process for each item
+            while (ok && workQueue.Any()) {
+
+                var workItem = workItems[workQueue.Dequeue()];
+                Log.LogMessage(MessageImportance.High, workItem.Message);
+
+                try {
+                    var proc = Process.Start(workItem.ProcessStartInfo);
+                    proc.OutputDataReceived += (object sender, DataReceivedEventArgs e) =>
+                    {
+                        if (!string.IsNullOrEmpty(e.Data))
+                            Log.LogMessage(MessageImportance.High, string.Join(" ", new[]
+                            {
+                                (QtDebug ? "[" + (((Process)sender).Id.ToString()) + "]" : ""),
+                                e.Data
+                            }));
+                    };
+                    proc.ErrorDataReceived += (object sender, DataReceivedEventArgs e) =>
+                    {
+                        if (!string.IsNullOrEmpty(e.Data))
+                            Log.LogMessage(MessageImportance.High, string.Join(" ", new[]
+                            {
+                                (QtDebug ? "[" + (((Process)sender).Id.ToString()) + "]" : ""),
+                                e.Data
+                            }));
+                    };
+                    proc.BeginOutputReadLine();
+                    proc.BeginErrorReadLine();
+                    running.Enqueue(new KeyValuePair<string, Process>(workItem.Key, proc));
+                } catch (Exception e) {
+                    Log.LogError(
+                        string.Format("[QtRunWork] Error starting process {0}: {1}",
+                        workItem.ToolPath, e.Message));
+                    ok = false;
+                }
+
+                string qtDebugRunning = "";
+                if (QtDebug) {
+                    qtDebugRunning = string.Format("## QtRunWork waiting {0}",
+                        string.Join(", ", running
+                            .Select(x => string.Format("{0} [{1}]", x.Key, x.Value.Id))));
+                }
+
+                // Wait for process to terminate when there are processes running, and...
+                while (ok && running.Any()
+                    // ...work is queued but already reached the maximum number of processes, or...
+                    && ((workQueue.Any() && running.Count >= QtMaxProcs)
+                    // ...work queue is empty but there are dependents that haven't yet been queued
+                    || (!workQueue.Any() && postponedItems.Any()))) {
+
+                    var itemProc = running.Dequeue();
+                    workItem = workItems[itemProc.Key];
+                    var proc = itemProc.Value;
+
+                    if (QtDebug && !string.IsNullOrEmpty(qtDebugRunning)) {
+                        Log.LogMessage(MessageImportance.High, qtDebugRunning);
+                        qtDebugRunning = "";
+                    }
+
+                    if (proc.WaitForExit(100)) {
+                        if (QtDebug) {
+                            Log.LogMessage(MessageImportance.High,
+                                string.Format("## QtRunWork exit {0} [{1}] = {2} ({3:0.00} msecs)",
+                                workItem.Key, proc.Id, proc.ExitCode,
+                                (proc.ExitTime - proc.StartTime).TotalMilliseconds));
+                        }
+
+                        // Process terminated; check exit code and close
+                        terminated.Add(workItem.Key);
+                        result[workItem.Key].SetMetadata("ExitCode", proc.ExitCode.ToString());
+                        ok &= (proc.ExitCode == 0);
+                        proc.Close();
+
+                        // Add postponed dependent items to work queue
+                        if (ok && dependentsOf.ContainsKey(workItem.Key)) {
+                            // Dependents of workItem...
+                            var readyDependents = dependentsOf[workItem.Key]
+                                // ...that have not yet been queued...
+                                .Where(x => postponedItems.Contains(x)
+                                    // ...and whose dependending items have all terminated.
+                                    && workItems[x].DependsOn.All(y => terminated.Contains(y)));
+
+                            if (QtDebug && readyDependents.Any()) {
+                                Log.LogMessage(MessageImportance.High,
+                                string.Format("## QtRunWork queueing\r\n##    {0}",
+                                string.Join("\r\n##    ", readyDependents)));
+                            }
+
+                            foreach (var dependent in readyDependents) {
+                                postponedItems.Remove(dependent);
+                                workQueue.Enqueue(dependent);
+                            }
+                        }
+                    } else {
+                        // Process is still running; feed it back into the running queue
+                        running.Enqueue(itemProc);
+                    }
+                }
+            }
+
+            // If there are items still haven't been queued, that means a circular dependency exists
+            if (ok && postponedItems.Any()) {
+                ok = false;
+                Log.LogError("[QtRunWork] Error: circular dependency");
+                if (QtDebug) {
+                    Log.LogMessage(MessageImportance.High,
+                        string.Format("## QtRunWork circularity\r\n##    {0}",
+                        string.Join("\r\n##    ", postponedItems
+                            .Select(x => string.Format("{0} <- {1}", x,
+                                         string.Join(", ", workItems[x].DependsOn))))));
+                }
+            }
+
+            if (ok && QtDebug) {
+                Log.LogMessage(MessageImportance.High,
+                    "## QtRunWork all work queued");
+                if (running.Any()) {
+                    Log.LogMessage(MessageImportance.High,
+                        string.Format("## QtRunWork waiting {0}",
+                        string.Join(", ", running
+                            .Select(x => string.Format("{0} [{1}]", x.Key, x.Value.Id)))));
+                }
+            }
+
+            // Wait for all running processes to terminate
+            while (running.Any()) {
+                var itemProc = running.Dequeue();
+                var workItem = workItems[itemProc.Key];
+                var proc = itemProc.Value;
+                if (proc.WaitForExit(100)) {
+                    if (QtDebug) {
+                        Log.LogMessage(MessageImportance.High,
+                            string.Format("## QtRunWork exit {0} [{1}] = {2} ({3:0.00} msecs)",
+                            workItem.Key, proc.Id, proc.ExitCode,
+                            (proc.ExitTime - proc.StartTime).TotalMilliseconds));
+                    }
+                    // Process terminated; check exit code and close
+                    result[workItem.Key].SetMetadata("ExitCode", proc.ExitCode.ToString());
+                    ok &= (proc.ExitCode == 0);
+                    proc.Close();
+                } else {
+                    // Process is still running; feed it back into the running queue
+                    running.Enqueue(itemProc);
+                }
+            }
+
+            if (QtDebug) {
+                Log.LogMessage(MessageImportance.High,
+                    string.Format("## QtRunWork result {0}", (ok ? "ok" : "FAILED!")));
+            }
+
+            Result = result.Values.ToArray();
+            if (!ok)
+                return false;
+        ]]>
+      </Code>
+    </Task>
+  </UsingTask>
+
+  <!--
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  /// TASK ParseVarDefs
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  //
+  // -->
+  <UsingTask TaskName="ParseVarDefs"
+    TaskFactory="CodeTaskFactory" AssemblyFile="$(MSBuildToolsPath)\Microsoft.Build.Tasks.v4.0.dll">
+    <ParameterGroup>
+      <QtVars Required="true"
+        ParameterType="System.String"/>
+      <OutVarDefs Output="true"
+        ParameterType="Microsoft.Build.Framework.ITaskItem[]"/>
+    </ParameterGroup>
+    <Task>
+      <Using Namespace="System"/>
+      <Using Namespace="System.Text"/>
+      <Using Namespace="System.Text.RegularExpressions"/>
+      <Code Type="Fragment" Language="cs">
+        <![CDATA[
+            OutVarDefs = Regex.Matches(QtVars,
+                @"\s*(\w+)\s*(?:;|=\s*(\w*)\s*(?:\/((?:\\.|[^;\/])*)\/((?:\\.|[^;\/])*)\/)?)?")
+                .Cast<Match>()
+                .Where((Match x) => x.Groups.Count > 4 && !string.IsNullOrEmpty(x.Groups[1].Value))
+                .Select((Match x) => x.Groups
+                      .Cast<Group>()
+                      .Select((Group y) => !string.IsNullOrEmpty(y.Value) ? y.Value : null)
+                      .ToArray())
+                .Select((string[] x) => new TaskItem(x[1],
+                    new Dictionary<string,string>
+                    {
+                        { "Name" ,    x[2] ?? x[1] },
+                        { "Pattern" , x[3] ?? ".*" },
+                        { "Value" ,   x[4] ?? "$0" },
+                    }))
+                .ToArray();
+        ]]>
+      </Code>
+    </Task>
+  </UsingTask>
+
+  <!--
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  /// TASK GetVarsFromMakefile
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  //
+  // -->
+  <UsingTask TaskName="GetVarsFromMakefile"
+    TaskFactory="CodeTaskFactory" AssemblyFile="$(MSBuildToolsPath)\Microsoft.Build.Tasks.v4.0.dll">
+    <ParameterGroup>
+      <Makefile Required="true"
+        ParameterType="System.String"/>
+      <VarDefs Required="false"
+        ParameterType="Microsoft.Build.Framework.ITaskItem[]"/>
+      <ExcludeValues Required="true"
+        ParameterType="System.String[]"/>
+      <OutVars Output="true"
+        ParameterType="Microsoft.Build.Framework.ITaskItem[]"/>
+    </ParameterGroup>
+    <Task>
+      <Using Namespace="System"/>
+      <Using Namespace="System.Text"/>
+      <Using Namespace="System.Text.RegularExpressions"/>
+      <Using Namespace="System.IO"/>
+      <Code Type="Fragment" Language="cs">
+        <![CDATA[
+            var makefileVars = Regex.Matches(
+                File.ReadAllText(Makefile),
+                @"^(\w+)[^\=\r\n\S]*\=[^\r\n\S]*([^\r\n]+)[\r\n]",
+                RegexOptions.Multiline).Cast<Match>()
+                .Where(x => x.Groups.Count > 2 && x.Groups[1].Success && x.Groups[2].Success
+                    && !string.IsNullOrEmpty(x.Groups[1].Value))
+                .GroupBy(x => x.Groups[1].Value)
+                .ToDictionary(g => g.Key, g => g.Last().Groups[2].Value);
+            OutVars = VarDefs
+                .Where(x => makefileVars.ContainsKey(x.GetMetadata("Name")))
+                .Select(x => new TaskItem(x.ItemSpec, new Dictionary<string,string>
+                { {
+                    "Value",
+                    string.Join(";", Regex
+                        .Matches(makefileVars[x.GetMetadata("Name")], x.GetMetadata("Pattern"))
+                        .Cast<Match>()
+                        .Select(y => Regex
+                            .Replace(y.Value, x.GetMetadata("Pattern"), x.GetMetadata("Value")))
+                        .Where(y => !string.IsNullOrEmpty(y)
+                            && !ExcludeValues.Contains(y,
+                                StringComparer.InvariantCultureIgnoreCase))
+                        .ToHashSet())
+                } }))
+                .Where(x => !string.IsNullOrEmpty(x.GetMetadata("Value")))
+                .ToArray();
+        ]]>
+      </Code>
+    </Task>
+  </UsingTask>
+
+  <!--
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  /// TASK Flatten
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  // Destructure items into a "flat" list of metadata. The output is a list of (Name, Value) pairs,
+  // each corresponding to one item metadata. Semi-colon-separated lists will also expand to many
+  // items in the output list, with the metadata name shared among them.
+  // Example:
+  //     INPUT:
+  //         <QtMoc>
+  //           <InputFile>foo.h</InputFile>
+  //           <IncludePath>C:\FOO;D:\BAR</IncludePath>
+  //         </QtMoc>
+  //     OUTPUT:
+  //         <Result>
+  //           <Name>InputFile</Name>
+  //           <Value>foo.h</Value>
+  //         </Result>
+  //         <Result>
+  //           <Name>IncludePath</Name>
+  //           <Value>C:\FOO</Value>
+  //         </Result>
+  //         <Result>
+  //           <Name>IncludePath</Name>
+  //           <Value>D:\BAR</Value>
+  //         </Result>
+  // Parameters:
+  //      in ITaskItem[] Items:    list of items to flatten
+  //      in string[]    Metadata: names of metadata to look for; omit to include all metadata
+  //     out ITaskItem[] Result:   list of metadata from all items
+  // -->
+  <UsingTask TaskName="Flatten"
+    TaskFactory="CodeTaskFactory" AssemblyFile="$(MSBuildToolsPath)\Microsoft.Build.Tasks.v4.0.dll">
+    <ParameterGroup>
+      <Items    ParameterType="Microsoft.Build.Framework.ITaskItem[]" Required="true" />
+      <Metadata ParameterType="System.String[]"                       Required="false" />
+      <Result   ParameterType="Microsoft.Build.Framework.ITaskItem[]" Output="true" />
+    </ParameterGroup>
+    <Task>
+      <Using Namespace="System"/>
+      <Using Namespace="System.IO"/>
+      <Using Namespace="System.Diagnostics"/>
+      <Using Namespace="System.Collections.Generic"/>
+      <Code Type="Fragment" Language="cs">
+        <![CDATA[
+            Result = new ITaskItem[] { };
+            var reserved = new HashSet<string>
+            {
+                "AccessedTime", "CreatedTime", "DefiningProjectDirectory",
+                "DefiningProjectExtension", "DefiningProjectFullPath", "DefiningProjectName",
+                "Directory", "Extension", "Filename", "FullPath", "Identity", "ModifiedTime",
+                "RecursiveDir", "RelativeDir", "RootDir",
+            };
+            if (Metadata == null)
+                Metadata = new string[0];
+            var requestedNames = new HashSet<string>(Metadata.Where(x => !string.IsNullOrEmpty(x)));
+            var newItems = new List<ITaskItem>();
+            foreach (var item in Items) {
+                var itemName = item.ItemSpec;
+                var names = item.MetadataNames.Cast<string>().Where(x => !reserved.Contains(x)
+                    && (!requestedNames.Any() || requestedNames.Contains(x)));
+                foreach (string name in names) {
+                    var values = item.GetMetadata(name).Split(';');
+                    foreach (string value in values.Where(v => !string.IsNullOrEmpty(v))) {
+                        newItems.Add(new TaskItem(string.Format("{0}={1}", name, value),
+                            new Dictionary<string, string>
+                            {
+                                { "Item",  itemName },
+                                { "Name",  name },
+                                { "Value", value },
+                            }));
+                    }
+                }
+            }
+            Result = newItems.ToArray();
+        ]]>
+      </Code>
+    </Task>
+  </UsingTask>
+
+  <!--
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  /// TASK HostTranslatePaths
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  // Translate local (Windows) paths to build host paths. This could be a Linux host for cross
+  // compilation, or a simple copy (i.e. "no-op") when building in Windows.
+  // Input and output items are in the form:
+  //    <...>
+  //      <Item>...</Item>
+  //      <Name>...</Name>
+  //      <Value>...</Value>
+  //    </...>
+  // where <Item> is the local path, <Name> is a filter criteria identifier matched with the Names
+  // parameter, and <Value> is set to the host path in output items (for input items <Value> must
+  // be equal to <Item>).
+  // Parameters:
+  //      in ITaskItem[] Items:  input items with local paths
+  //      in string[]    Names:  filter criteria; unmatched items will simply be copied (i.e. no-op)
+  //     out ITaskItem[] Result: output items with translated host paths
+  // -->
+  <!--// Linux build over WSL -->
+  <UsingTask TaskName="HostTranslatePaths" TaskFactory="CodeTaskFactory"
+    Condition="'$(ApplicationType)' == 'Linux' AND '$(PlatformToolset)' == 'WSL_1_0'"
+    AssemblyFile="$(MSBuildToolsPath)\Microsoft.Build.Tasks.Core.dll">
+    <ParameterGroup>
+      <Items  ParameterType="Microsoft.Build.Framework.ITaskItem[]" Required="true" />
+      <Names  ParameterType="System.String[]"                       Required="false" />
+      <Result ParameterType="Microsoft.Build.Framework.ITaskItem[]" Output="true" />
+    </ParameterGroup>
+    <Task>
+      <Reference Include="$(VCTargetsPath)\Application Type\Linux\1.0\liblinux.dll"/>
+      <Using Namespace="System.IO"/>
+      <Using Namespace="liblinux"/>
+      <Using Namespace="liblinux.IO"/>
+      <Code Type="Fragment" Language="cs">
+        <![CDATA[
+          Result = new ITaskItem[] { };
+          var newItems = new List<ITaskItem>();
+          foreach (var item in Items) {
+              string itemName = item.GetMetadata("Name");
+              string itemValue = item.GetMetadata("Value");
+              if (Names.Contains(itemName)) {
+                  if (Path.IsPathRooted(itemValue) && !itemValue.StartsWith("/"))
+                      itemValue = PathUtils.TranslateWindowsPathToWSLPath(itemValue);
+                  else
+                      itemValue = itemValue.Replace(@"\", "/");
+              }
+              newItems.Add(new TaskItem(item.ItemSpec,
+                  new Dictionary<string, string>
+                  {
+                      { "Item",  item.GetMetadata("Item") },
+                      { "Name",  itemName },
+                      { "Value", itemValue },
+                  }));
+          }
+          Result = newItems.ToArray();
+        ]]>
+      </Code>
+    </Task>
+  </UsingTask>
+  <!--// Linux build over SSH -->
+  <UsingTask TaskName="HostTranslatePaths" TaskFactory="CodeTaskFactory"
+    Condition="'$(ApplicationType)' == 'Linux' AND '$(PlatformToolset)' != 'WSL_1_0'"
+    AssemblyFile="$(MSBuildToolsPath)\Microsoft.Build.Tasks.Core.dll">
+    <ParameterGroup>
+      <Items  ParameterType="Microsoft.Build.Framework.ITaskItem[]" Required="true" />
+      <Names  ParameterType="System.String[]"                       Required="false" />
+      <Result ParameterType="Microsoft.Build.Framework.ITaskItem[]" Output="true" />
+    </ParameterGroup>
+    <Task>
+      <Reference
+        Include="$(VCTargetsPath)\Application Type\Linux\1.0\Microsoft.Build.Linux.Tasks.dll"/>
+      <Code Type="Fragment" Language="cs">
+        <![CDATA[
+          Result = new ITaskItem[] { };
+          var newItems = new List<ITaskItem>();
+          foreach (var item in Items) {
+              string itemName = item.GetMetadata("Name");
+              string itemValue = item.GetMetadata("Value");
+              if (Names.Contains(itemName)) {
+                  if (Path.IsPathRooted(itemValue) && !itemValue.StartsWith("/")) {
+                      var projectdir = new Uri(@"$(ProjectDir)");
+                      var itemFileName = Path.GetFileName(itemValue);
+                      var itemDirName = Path.GetFullPath(Path.GetDirectoryName(itemValue));
+                      if (!itemDirName.EndsWith(@"\"))
+                          itemDirName += @"\";
+                      var itemDir = new Uri(itemDirName);
+                      if (projectdir.IsBaseOf(itemDir)) {
+                          itemValue = projectdir.MakeRelativeUri(itemDir).OriginalString
+                            + itemFileName;
+                      } else {
+                          Log.LogWarning("Unable to translate path: {0}", itemValue);
+                      }
+                  } else {
+                      itemValue = itemValue.Replace(@"\", "/");
+                  }
+              }
+              newItems.Add(new TaskItem(item.ItemSpec,
+                  new Dictionary<string, string>
+                  {
+                      { "Item",  item.GetMetadata("Item") },
+                      { "Name",  itemName },
+                      { "Value", itemValue },
+                  }));
+          }
+          Result = newItems.ToArray();
+        ]]>
+      </Code>
+    </Task>
+  </UsingTask>
+  <!--// Local (Windows) build -->
+  <UsingTask TaskName="HostTranslatePaths" TaskFactory="CodeTaskFactory"
+    Condition="'$(ApplicationType)' != 'Linux'"
+    AssemblyFile="$(MSBuildToolsPath)\Microsoft.Build.Tasks.Core.dll">
+    <ParameterGroup>
+      <Items  ParameterType="Microsoft.Build.Framework.ITaskItem[]" Required="true" />
+      <Names  ParameterType="System.String[]"                       Required="false" />
+      <Result ParameterType="Microsoft.Build.Framework.ITaskItem[]" Output="true" />
+    </ParameterGroup>
+    <Task>
+      <Code Type="Fragment" Language="cs">
+        <![CDATA[
+          Result = Items.ToArray();
+        ]]>
+      </Code>
+    </Task>
+  </UsingTask>
+
+  <!--
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  /// TASK HostExec
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  // Run command in build host.
+  // Parameters:
+  //     in string      Command: Command to run on the build host
+  //     in string      RedirectStdOut: Path to file to receive redirected output messages
+  //                      * can be NUL to discard messages
+  //     in string      RedirectStdErr: Path to file to receive redirected error messages
+  //                      * can be NUL to discard messages
+  //                      * can be STDOUT to apply the same redirection as output messages
+  //     in string      WorkingDirectory: Path to directory where command will be run
+  //     in ITaskItem[] Inputs: List of local -> host path mappings for command inputs
+  //                      * item format: cf. HostTranslatePaths task
+  //     in ITaskItem[] Outputs: List of host -> local path mappings for command outputs
+  //                      * item format: cf. HostTranslatePaths task
+  //     in string      RemoteTarget: Set by ResolveRemoteDir in SSH mode; null otherwise
+  //     in string      RemoteProjectDir: Set by ResolveRemoteDir in SSH mode; null otherwise
+  //     in bool        IgnoreExitCode: Set flag to disable build error if command failed
+  //    out int         ExitCode: status code at command exit
+  // -->
+  <!--// Linux build over WSL -->
+  <UsingTask TaskName="HostExec" TaskFactory="CodeTaskFactory"
+    Condition="'$(ApplicationType)' == 'Linux' AND '$(PlatformToolset)' == 'WSL_1_0'"
+    AssemblyFile="$(MSBuildToolsPath)\Microsoft.Build.Tasks.Core.dll">
+    <ParameterGroup>
+      <!--IN-->
+      <Message          ParameterType="System.String"                         Required="false" />
+      <Command          ParameterType="System.String"                         Required="true"  />
+      <RedirectStdOut   ParameterType="System.String"                         Required="false" />
+      <RedirectStdErr   ParameterType="System.String"                         Required="false" />
+      <WorkingDirectory ParameterType="System.String"                         Required="false" />
+      <Inputs           ParameterType="Microsoft.Build.Framework.ITaskItem[]" Required="false" />
+      <Outputs          ParameterType="Microsoft.Build.Framework.ITaskItem[]" Required="false" />
+      <RemoteTarget     ParameterType="System.String"                         Required="false" />
+      <RemoteProjectDir ParameterType="System.String"                         Required="false" />
+      <IgnoreExitCode   ParameterType="System.Boolean"                        Required="false" />
+      <!--OUT-->
+      <ExitCode         ParameterType="System.Int32"                          Output="true" />
+    </ParameterGroup>
+    <Task>
+      <Reference
+        Include="$(VCTargetsPath)\Application Type\Linux\1.0\Microsoft.Build.Linux.Tasks.dll"/>
+      <Code Type="Fragment" Language="cs">
+        <![CDATA[
+          if (!string.IsNullOrEmpty(Message))
+              Log.LogMessage(MessageImportance.High, Message);
+          Command = "(" + Command + ")";
+          if (RedirectStdOut == "NUL" || RedirectStdOut == "/dev/null")
+            Command += " 1> /dev/null";
+          else if (!string.IsNullOrEmpty(RedirectStdOut))
+            Command += " 1> " + RedirectStdOut;
+          if (RedirectStdErr == "NUL" || RedirectStdErr == "/dev/null")
+            Command += " 2> /dev/null";
+          else if (RedirectStdErr == "STDOUT")
+            Command += " 2>&1";
+          else if (!string.IsNullOrEmpty(RedirectStdErr))
+            Command += " 2> " + RedirectStdErr;
+
+          var createDirs = new List<string>();
+          if (Inputs != null) {
+              createDirs.AddRange(Inputs
+                  .Select(x => string.Format("\x24(dirname {0})", x.GetMetadata("Value"))));
+          }
+          if (Outputs != null) {
+              createDirs.AddRange(Outputs
+                  .Select(x => string.Format("\x24(dirname {0})", x.GetMetadata("Value"))));
+          }
+          if (!string.IsNullOrEmpty(WorkingDirectory)) {
+              createDirs.Add(WorkingDirectory);
+              Command = string.Format("cd {0}; {1}", WorkingDirectory, Command);
+          }
+          if (createDirs.Any()) {
+              Command = string.Format("{0}; {1}",
+                  string.Join("; ", createDirs.Select(x => string.Format("mkdir -p {0}", x))),
+                  Command);
+          }
+
+          var taskExec = new Microsoft.Build.Linux.WSL.Tasks.ExecuteCommand()
+          {
+              BuildEngine = BuildEngine,
+              HostObject = HostObject,
+              ProjectDir = @"$(ProjectDir)",
+              IntermediateDir = @"$(IntDir)",
+              WSLPath = @"$(WSLPath)",
+              Command = Command,
+          };
+          Log.LogMessage("\r\n==== HostExec: Microsoft.Build.Linux.WSL.Tasks.ExecuteCommand");
+          Log.LogMessage("ProjectDir: {0}", taskExec.ProjectDir);
+          Log.LogMessage("IntermediateDir: {0}", taskExec.IntermediateDir);
+          Log.LogMessage("WSLPath: {0}", taskExec.WSLPath);
+          Log.LogMessage("Command: {0}", taskExec.Command);
+
+          bool ok = taskExec.Execute();
+          Log.LogMessage("== {0} ExitCode: {1}\r\n", ok ? "OK" : "FAIL", taskExec.ExitCode);
+
+          ExitCode = taskExec.ExitCode;
+          if (!ok && !IgnoreExitCode) {
+              Log.LogError("Host command failed.");
+              return false;
+          }
+        ]]>
+      </Code>
+    </Task>
+  </UsingTask>
+  <!--// Linux build over SSH -->
+  <UsingTask TaskName="HostExec" TaskFactory="CodeTaskFactory"
+    Condition="'$(ApplicationType)' == 'Linux' AND '$(PlatformToolset)' != 'WSL_1_0'"
+    AssemblyFile="$(MSBuildToolsPath)\Microsoft.Build.Tasks.Core.dll">
+    <ParameterGroup>
+      <!--IN-->
+      <Message          ParameterType="System.String"                         Required="false" />
+      <Command          ParameterType="System.String"                         Required="true"  />
+      <RedirectStdOut   ParameterType="System.String"                         Required="false" />
+      <RedirectStdErr   ParameterType="System.String"                         Required="false" />
+      <WorkingDirectory ParameterType="System.String"                         Required="false" />
+      <Inputs           ParameterType="Microsoft.Build.Framework.ITaskItem[]" Required="false" />
+      <Outputs          ParameterType="Microsoft.Build.Framework.ITaskItem[]" Required="false" />
+      <RemoteTarget     ParameterType="System.String"                         Required="false" />
+      <RemoteProjectDir ParameterType="System.String"                         Required="false" />
+      <IgnoreExitCode   ParameterType="System.Boolean"                        Required="false" />
+      <!--OUT-->
+      <ExitCode         ParameterType="System.Int32"                          Output="true" />
+    </ParameterGroup>
+    <Task>
+      <Reference
+          Include="$(VCTargetsPath)\Application Type\Linux\1.0\Microsoft.Build.Linux.Tasks.dll"/>
+      <Code Type="Fragment" Language="cs">
+        <![CDATA[
+          if (!string.IsNullOrEmpty(Message))
+              Log.LogMessage(MessageImportance.High, Message);
+          var createDirs = new List<string>
+          {
+              string.Format("{0}/{1}", RemoteProjectDir, WorkingDirectory)
+          };
+
+          var localFilesToCopyRemotelyMapping = new string[0];
+          if (Inputs != null) {
+              localFilesToCopyRemotelyMapping = Inputs
+                  .Select(x => string.Format(@"{0}:={1}/{2}",
+                      x.GetMetadata("Item"),
+                      RemoteProjectDir,
+                      x.GetMetadata("Value")))
+                  .ToArray();
+              createDirs.AddRange(Inputs
+                  .Select(x => string.Format("\x24(dirname {0})", x.GetMetadata("Value"))));
+          }
+
+          var remoteFilesToCopyLocallyMapping = new string[0];
+          if (Outputs != null) {
+              remoteFilesToCopyLocallyMapping = Outputs
+                .Select(x => string.Format(@"{0}/{1}:={2}",
+                    RemoteProjectDir,
+                    x.GetMetadata("Value"),
+                    x.GetMetadata("Item")))
+                .ToArray();
+              createDirs.AddRange(Outputs
+                  .Select(x => string.Format("\x24(dirname {0})", x.GetMetadata("Value"))));
+          }
+
+          Command = "(" + Command + ")";
+          if (RedirectStdOut == "NUL" || RedirectStdOut == "/dev/null")
+            Command += " 1> /dev/null";
+          else if (!string.IsNullOrEmpty(RedirectStdOut))
+            Command += " 1> " + RedirectStdOut;
+          if (RedirectStdErr == "NUL" || RedirectStdErr == "/dev/null")
+            Command += " 2> /dev/null";
+          else if (RedirectStdErr == "STDOUT")
+            Command += " 2>&1";
+          else if (!string.IsNullOrEmpty(RedirectStdErr))
+            Command += " 2> " + RedirectStdErr;
+          Command = string.Format("cd {0}/{1}; {2}", RemoteProjectDir, WorkingDirectory, Command);
+
+          var taskCopyFiles = new Microsoft.Build.Linux.Tasks.Execute()
+          {
+              BuildEngine = BuildEngine,
+              HostObject = HostObject,
+              ProjectDir = @"$(ProjectDir)",
+              IntermediateDir = @"$(IntDir)",
+              RemoteTarget = RemoteTarget,
+              RemoteProjectDir = RemoteProjectDir,
+              Command = string.Join("; ", createDirs.Select(x => string.Format("mkdir -p {0}", x))),
+              LocalFilesToCopyRemotelyMapping = localFilesToCopyRemotelyMapping,
+          };
+          var taskExec = new Microsoft.Build.Linux.Tasks.Execute()
+          {
+              BuildEngine = BuildEngine,
+              HostObject = HostObject,
+              ProjectDir = @"$(ProjectDir)",
+              IntermediateDir = @"$(IntDir)",
+              RemoteTarget = RemoteTarget,
+              RemoteProjectDir = RemoteProjectDir,
+              Command = Command,
+              RemoteFilesToCopyLocallyMapping = remoteFilesToCopyLocallyMapping,
+          };
+
+          Log.LogMessage("\r\n==== HostExec: Microsoft.Build.Linux.Tasks.Execute");
+          Log.LogMessage("ProjectDir: {0}", taskExec.ProjectDir);
+          Log.LogMessage("IntermediateDir: {0}", taskExec.IntermediateDir);
+          Log.LogMessage("RemoteTarget: {0}", taskExec.RemoteTarget);
+          Log.LogMessage("RemoteProjectDir: {0}", taskExec.RemoteProjectDir);
+          if (taskExec.LocalFilesToCopyRemotelyMapping.Any())
+              Log.LogMessage("LocalFilesToCopyRemotelyMapping: {0}",
+                  taskExec.LocalFilesToCopyRemotelyMapping);
+          if (taskExec.RemoteFilesToCopyLocallyMapping.Any())
+              Log.LogMessage("RemoteFilesToCopyLocallyMapping: {0}",
+                  taskExec.RemoteFilesToCopyLocallyMapping);
+          Log.LogMessage("CreateDirs: {0}", taskCopyFiles.Command);
+          Log.LogMessage("Command: {0}", taskExec.Command);
+
+          if (!taskCopyFiles.ExecuteTool())
+              return false;
+          bool ok = taskExec.ExecuteTool();
+          Log.LogMessage("== {0} ExitCode: {1}\r\n", ok ? "OK" : "FAIL", taskExec.ExitCode);
+
+          ExitCode = taskExec.ExitCode;
+          if (!ok && !IgnoreExitCode) {
+              Log.LogError("Host command failed.");
+              return false;
+          }
+        ]]>
+      </Code>
+    </Task>
+  </UsingTask>
+  <!--// Local (Windows) build -->
+  <UsingTask TaskName="HostExec" TaskFactory="CodeTaskFactory"
+    Condition="'$(ApplicationType)' != 'Linux'"
+    AssemblyFile="$(MSBuildToolsPath)\Microsoft.Build.Tasks.Core.dll">
+    <ParameterGroup>
+      <!--IN-->
+      <Message          ParameterType="System.String"                         Required="false" />
+      <Command          ParameterType="System.String"                         Required="true"  />
+      <RedirectStdOut   ParameterType="System.String"                         Required="false" />
+      <RedirectStdErr   ParameterType="System.String"                         Required="false" />
+      <WorkingDirectory ParameterType="System.String"                         Required="false" />
+      <Inputs           ParameterType="Microsoft.Build.Framework.ITaskItem[]" Required="false" />
+      <Outputs          ParameterType="Microsoft.Build.Framework.ITaskItem[]" Required="false" />
+      <RemoteTarget     ParameterType="System.String"                         Required="false" />
+      <RemoteProjectDir ParameterType="System.String"                         Required="false" />
+      <IgnoreExitCode   ParameterType="System.Boolean"                        Required="false" />
+      <!--OUT-->
+      <ExitCode         ParameterType="System.Int32"                          Output="true" />
+    </ParameterGroup>
+    <Task>
+      <Reference Include="$(MSBuildToolsPath)\Microsoft.Build.Tasks.Core.dll"/>
+      <Reference Include="$(MSBuildToolsPath)\Microsoft.Build.Utilities.Core.dll"/>
+      <Code Type="Fragment" Language="cs">
+        <![CDATA[
+          if (!string.IsNullOrEmpty(Message))
+              Log.LogMessage(MessageImportance.High, Message);
+          Command = "(" + Command + ")";
+          if (RedirectStdOut == "NUL" || RedirectStdOut == "/dev/null")
+            Command += " 1> NUL";
+          else if (!string.IsNullOrEmpty(RedirectStdOut))
+            Command += " 1> " + RedirectStdOut;
+          if (RedirectStdErr == "NUL" || RedirectStdErr == "/dev/null")
+            Command += " 2> NUL";
+          else if (RedirectStdErr == "STDOUT")
+            Command += " 2>&1";
+          else if (!string.IsNullOrEmpty(RedirectStdErr))
+            Command += " 2> " + RedirectStdErr;
+
+          var taskExec = new Microsoft.Build.Tasks.Exec()
+          {
+              BuildEngine = BuildEngine,
+              HostObject = HostObject,
+              WorkingDirectory = WorkingDirectory,
+              Command = Command,
+              IgnoreExitCode = IgnoreExitCode,
+          };
+
+          Log.LogMessage("\r\n==== HostExec: Microsoft.Build.Tasks.Exec");
+          Log.LogMessage("WorkingDirectory: {0}", taskExec.WorkingDirectory);
+          Log.LogMessage("Command: {0}", taskExec.Command);
+
+          bool ok = taskExec.Execute();
+          Log.LogMessage("== {0} ExitCode: {1}\r\n", ok ? "OK" : "FAIL", taskExec.ExitCode);
+
+          ExitCode = taskExec.ExitCode;
+          if (!ok)
+              return false;
+        ]]>
+      </Code>
+    </Task>
+  </UsingTask>
+</Project>
diff --git a/Source/VSProps/qtmoc.props b/Source/VSProps/qtmoc.props
new file mode 100644
index 0000000000..f46aad3fa1
--- /dev/null
+++ b/Source/VSProps/qtmoc.props
@@ -0,0 +1,83 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/****************************************************************************
+**
+** Copyright (C) 2019 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the Qt VS Tools.
+**
+** $QT_BEGIN_LICENSE:GPL-EXCEPT$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 as published by the Free Software
+** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+-->
+<!--
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Qt/MSBuild moc property definitions
+// -->
+<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  // Import pre-requisites
+  // -->
+  <Import
+    Condition="'$(QtMsBuildProps_BeforeMoc)' != ''"
+    Project="$(QtMsBuildProps_BeforeMoc)"/>
+
+  <!--
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  // QtMoc item template
+  // -->
+  <ItemDefinitionGroup>
+    <QtMoc>
+      <ExecutionDescription>moc %(Identity)</ExecutionDescription>
+
+      <QTDIR Condition="'$(QtVsProjectSettings)' != 'true'"
+        >$(QTDIR)</QTDIR>
+      <QTDIR Condition="'$(QtVsProjectSettings)' == 'true'"
+        >$(QtInstallDir)</QTDIR>
+
+      <InputFile>%(FullPath)</InputFile>
+
+      <OutputFile Condition="'$(QtVsProjectSettings)' != 'true'"
+        >$(ProjectDir)GeneratedFiles\$(Configuration)\moc_%(Filename).cpp</OutputFile>
+
+      <QtMocDir Condition="'$(QtVsProjectSettings)' == 'true'"
+        >$(IntDir)moc\</QtMocDir>
+      <QtMocFileName Condition="'$(QtVsProjectSettings)' == 'true'"
+        >moc_%(Filename).cpp</QtMocFileName>
+
+      <DynamicSource>output</DynamicSource>
+      <ParallelProcess>true</ParallelProcess>
+      <CommandLineTemplate>[AllOptions] [AdditionalOptions]</CommandLineTemplate>
+      <Outputs>%(OutputFile)</Outputs>
+      <OverrideClCompile>false</OverrideClCompile>
+    </QtMoc>
+  </ItemDefinitionGroup>
+
+  <!--
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  // Import dependants
+  // -->
+  <Import
+    Condition="'$(QtMsBuildProps_AfterMoc)' != ''"
+    Project="$(QtMsBuildProps_AfterMoc)"/>
+
+</Project>
diff --git a/Source/VSProps/qtmoc.targets b/Source/VSProps/qtmoc.targets
new file mode 100644
index 0000000000..2db1b04ae7
--- /dev/null
+++ b/Source/VSProps/qtmoc.targets
@@ -0,0 +1,510 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/****************************************************************************
+**
+** Copyright (C) 2018 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the Qt VS Tools.
+**
+** $QT_BEGIN_LICENSE:GPL-EXCEPT$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 as published by the Free Software
+** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+-->
+
+<!--
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Definitions specific to moc
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// -->
+<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  // Import pre-requisites
+  // -->
+  <Import
+    Condition="'$(QtMsBuildTargets_BeforeMoc)' != ''"
+    Project="$(QtMsBuildTargets_BeforeMoc)"/>
+
+  <!--
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  // Qt/MSBuild global properties
+  // -->
+  <PropertyGroup>
+    <QtBuildTargets>QtMoc;$(QtBuildTargets)</QtBuildTargets>
+  </PropertyGroup>
+
+  <!--
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  // Setup item type and property page
+  // -->
+  <Choose>
+    <When Condition="'$(QtVsProjectSettings)' == 'true' AND '$(QtVsProjectClProperties)' == 'true'">
+      <ItemGroup>
+        <PropertyPageSchema
+          Include="$(MSBuildThisFileDirectory)qtmoc_v3.xml" />
+      </ItemGroup>
+    </When>
+    <Otherwise>
+      <ItemGroup Condition="'$(QtVsProjectSettings)' == 'false'">
+        <PropertyPageSchema
+          Include="$(MSBuildThisFileDirectory)qtmoc.xml" />
+      </ItemGroup>
+    </Otherwise>
+  </Choose>
+  <ItemGroup>
+    <AvailableItemName Include="QtMoc">
+      <Targets>Qt;_ClCompile</Targets>
+    </AvailableItemName>
+  </ItemGroup>
+  <PropertyGroup>
+    <QtMocRuleName>QtRule30_Moc</QtMocRuleName>
+  </PropertyGroup>
+
+  <!--
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  /// TARGET QtMocInit
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  // Initialize default metadata
+  // -->
+  <Target Name="QtMocInit">
+    <!--// Initialize %(OutputFile) -->
+    <ItemGroup Condition="'$(QtVsProjectSettings)' == 'true' AND '@(QtMoc)' != ''">
+      <QtMocAux Include="@(QtMoc)">
+        <OutputFile
+          >$([System.IO.Path]::Combine('%(QtMoc.QtMocDir)','%(QtMoc.QtMocFileName)'))</OutputFile>
+      </QtMocAux>
+      <QtMoc Remove="@(QtMoc)"/>
+      <QtMoc Include="@(QtMocAux)"/>
+      <QtMocAux Remove="@(QtMocAux)"/>
+    </ItemGroup>
+    <!--
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    // Add moc output dir to C++ include path
+    // -->
+    <ItemGroup Condition="'@(QtMoc)' != ''">
+      <QtIncludePath Include="$([System.IO.Path]::GetDirectoryName('%(QtMoc.OutputFile)'))"/>
+    </ItemGroup>
+  </Target>
+
+  <!--
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  /// TARGET QtMocPrepare
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  // Prepare to process sources
+  // -->
+  <Target Name="QtMocPrepare" DependsOnTargets="_SelectedFiles;QtMocInit"
+    Inputs="%(QtMoc.Identity)" Outputs="@(QtMoc->'####### Don't skip this target #######')">
+
+    <Message Importance="High" Condition="'$(QtDebug)' == 'true'"
+        Text="## QtMocPrepare @(QtMoc)"/>
+
+    <PropertyGroup>
+      <selected_files>[@(SelectedFiles->'%(Identity)','][')]</selected_files>
+      <file>[@(QtMoc->'%(Identity)')]</file>
+      <output_file>@(QtMoc->'%(OutputFile)')</output_file>
+      <is_selected Condition="$(selected_files.Contains('$(file)'))">true</is_selected>
+      <is_selected Condition="!$(selected_files.Contains('$(file)'))">false</is_selected>
+    </PropertyGroup>
+
+    <!--// Delete output file to force build of source if it was manually selected to build
+        //  (e.g. by the 'Compile' option in the context menu for the file) -->
+    <Delete Files="$(output_file)"
+      Condition="'$(SelectedFiles)' != '' AND '$(is_selected)' == 'true'" />
+
+    <!--// If a source was manually selected to build, remove all other sources -->
+    <ItemGroup Condition="'@(SelectedFiles)' != ''">
+      <QtMoc Remove="@(QtMoc)"
+        Condition="'$(SelectedFiles)' != '' AND '$(is_selected)' != 'true'" />
+    </ItemGroup>
+
+    <!--// Remove sources excluded from build -->
+    <ItemGroup>
+      <QtMoc Remove="@(QtMoc)"
+        Condition="'$(SelectedFiles)' == '' AND '%(QtMoc.ExcludedFromBuild)' == 'true'"/>
+    </ItemGroup>
+
+    <PropertyGroup>
+      <selected_files/>
+      <file/>
+      <output_file/>
+      <is_selected/>
+    </PropertyGroup>
+  </Target>
+
+  <!--
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  /// TARGET QtMocSetModified
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  // Set InputChanged flag if source file or dependencies have been modified
+  // -->
+  <Target Name="QtMocSetModified" DependsOnTargets="QtMocPrepare"
+    Condition="'@(QtMoc)' != ''"
+    Inputs="%(QtMoc.FullPath);%(QtMoc.AdditionalDependencies)" Outputs="@(QtMoc->'%(OutputFile)')">
+
+    <Message Importance="High" Condition="'$(QtDebug)' == 'true'"
+      Text="## QtMocSetModified @(QtMoc)" />
+
+    <CreateProperty Value="true">
+      <Output TaskParameter="ValueSetByTask" PropertyName="input_changed" />
+    </CreateProperty>
+    <ItemGroup>
+      <QtMoc>
+        <InputChanged>$(input_changed)</InputChanged>
+      </QtMoc>
+    </ItemGroup>
+  </Target>
+
+  <!--
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  /// TARGET QtMocOverrideCpp
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  //
+  // -->
+  <Import Project="qtmoc_cl.targets"/>
+
+  <!--
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  /// TARGET QtMoc
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  // Process each source file and produce the corresponding QtWork items
+  // -->
+  <PropertyGroup>
+    <QtMocDependsOn>
+      QtPrepare;
+      QtMocPrepare;
+      QtMocSetModified;
+      QtMocOverrideCpp;
+      $(QtMocDependsOn)
+    </QtMocDependsOn>
+  </PropertyGroup>
+  <Target Name="QtMoc"
+    DependsOnTargets="$(QtMocDependsOn)"
+    BeforeTargets="$(QtMocBeforeTargets)" AfterTargets="$(QtMocAfterTargets)"
+    Condition="'@(QtMoc)' != ''"
+    Inputs="%(QtMoc.FullPath);%(QtMoc.AdditionalDependencies);$(MSBuildProjectFile)"
+    Outputs="@(QtMoc->'%(OutputFile)')">
+
+    <Message Importance="High" Condition="'$(QtDebug)' == 'true'" Text="## QtMoc @(QtMoc)" />
+
+    <CreateProperty Value="true">
+      <Output TaskParameter="ValueSetByTask" PropertyName="dependencies_changed" />
+    </CreateProperty>
+
+    <!--
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    // Convert string lists in source item properties to lists of items
+    // -->
+    <Flatten Items="@(QtMoc)"
+      Metadata="InputFile;
+                OutputFile;
+                IncludePath;
+                MacFramework;
+                PreprocessOnly;
+                Define;
+                Undefine;
+                Metadata;
+                CompilerFlavor;
+                NoInclude;
+                PathPrefix;
+                ForceInclude;
+                PrependInclude;
+                Include;
+                NoNotesWarnings;
+                NoNotes;
+                NoWarnings;
+                IgnoreConflicts;
+                OptionsFile">
+      <Output
+        TaskParameter="Result" ItemName="options" />
+    </Flatten>
+
+    <!--
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    // Translate local paths to build host paths
+    // -->
+    <HostTranslatePaths
+      Items="@(options)"
+      Names="InputFile;
+            OutputFile;
+            IncludePath;
+            MacFramework;
+            PathPrefix;
+            ForceInclude;
+            PrependInclude;
+            Include;
+            OptionsFile">
+      <Output
+        TaskParameter="Result" ItemName="HostPath" />
+    </HostTranslatePaths>
+    <ItemGroup>
+      <options Condition="'%(Identity)' != ''">
+        <Value>@(HostPath->'%(Value)')</Value>
+      </options>
+    </ItemGroup>
+
+    <ItemGroup>
+      <!--
+      /////////////////////////////////////////////////////////////////////////////////////////////
+      // Escape double-quotes in macro definitions
+      // -->
+      <options>
+        <Value Condition="('%(Name)' == 'Define' OR '%(Name)' == 'Undefine')
+          AND ($([System.String]::Copy('%(Value)').Contains(' '))
+            OR $([System.String]::Copy('%(Value)').Contains('&quot;')))"
+          > &quot;$([System.String]::Copy('%(Value)').Replace('&quot;', '\&quot;'))&quot;</Value>
+      </options>
+
+      <!--
+      /////////////////////////////////////////////////////////////////////////////////////////////
+      // Remove quotes from all paths
+      // Escape trailing back-slash in paths
+      // Add quotes to paths containing spaces
+      // -->
+      <options>
+        <Value Condition="'%(Name)' == 'InputFile' OR '%(Name)' == 'OutputFile'
+          OR '%(Name)' == 'IncludePath' OR '%(Name)' == 'MacFramework' OR '%(Name)' == 'PathPrefix'
+          OR '%(Name)' == 'ForceInclude' OR '%(Name)' == 'PrependInclude' OR '%(Name)' == 'Include'
+          OR '%(Name)' == 'OptionsFile'"
+          >$([System.String]::Copy('%(Value)').Replace('&quot;', ''))</Value>
+      </options>
+
+      <options>
+        <Value Condition="('%(Name)' == 'InputFile' OR '%(Name)' == 'OutputFile'
+          OR '%(Name)' == 'IncludePath' OR '%(Name)' == 'MacFramework' OR '%(Name)' == 'PathPrefix'
+          OR '%(Name)' == 'ForceInclude' OR '%(Name)' == 'PrependInclude' OR '%(Name)' == 'Include'
+          OR '%(Name)' == 'OptionsFile')
+          AND $([System.String]::Copy('%(Value)').Contains(' '))
+          AND $([System.String]::Copy('%(Value)').EndsWith('\'))"
+          >%(Value)\</Value>
+      </options>
+
+      <options>
+        <Value Condition="('%(Name)' == 'InputFile' OR '%(Name)' == 'OutputFile'
+          OR '%(Name)' == 'IncludePath' OR '%(Name)' == 'MacFramework' OR '%(Name)' == 'PathPrefix'
+          OR '%(Name)' == 'ForceInclude' OR '%(Name)' == 'PrependInclude' OR '%(Name)' == 'Include'
+          OR '%(Name)' == 'OptionsFile')
+          AND $([System.String]::Copy('%(Value)').Contains(' '))"
+          >&quot;%(Value)&quot;</Value>
+      </options>
+
+    <!--
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    // Generate tool command line arguments
+    // -->
+      <!--//  [header-file]               Header file to read from -->
+      <options>
+        <Value Condition="'%(Name)' == 'InputFile'">%(Value)</Value>
+      </options>
+
+      <!--//  -o <file>                   Write output to file -->
+      <options>
+        <Value Condition="'%(Name)' == 'OutputFile'">-o %(Value)</Value>
+      </options>
+
+      <!--//  -I <dir>                    Add dir to the include path for header files -->
+      <options>
+        <Value Condition="'%(Name)' == 'IncludePath'">-I%(Value)</Value>
+      </options>
+
+      <!--//  -F <framework>              Add macOS framework to the include path for headers -->
+      <options>
+        <Value Condition="'%(Name)' == 'MacFramework'">-F %(Value)</Value>
+      </options>
+
+      <!--//  -E                          Preprocess only; do not generate meta object code -->
+      <options>
+        <Value Condition="'%(Name)' == 'PreprocessOnly' AND '%(Value)' != 'true'"></Value>
+      </options>
+      <options>
+        <Value Condition="'%(Name)' == 'PreprocessOnly' AND '%(Value)' == 'true'">-E</Value>
+      </options>
+
+      <!--//  -D <macro[=def]>            Define macro, with optional definition -->
+      <options>
+        <Value Condition="'%(Name)' == 'Define'">-D%(Value)</Value>
+      </options>
+
+      <!--//  -U <macro>                  Undefine macro-->
+      <options>
+        <Value Condition="'%(Name)' == 'Undefine'">-U%(Value)</Value>
+      </options>
+
+      <!--//  -M <key=value>              Add key/value pair to plugin meta data -->
+      <options>
+        <Value Condition="'%(Name)' == 'Metadata'">-M%(Value)</Value>
+      </options>
+
+      <!--//   -compiler-flavor <flavor>  Set the compiler flavor: either "msvc" or "unix" -->
+      <options>
+        <Value Condition="'%(Name)' == 'CompilerFlavor'">--compiler-flavor %(Value)</Value>
+      </options>
+
+      <!--//  -i                          Do not generate an #include statement -->
+      <options>
+        <Value Condition="'%(Name)' == 'NoInclude' AND '%(Value)' != 'true'"></Value>
+      </options>
+      <options>
+        <Value Condition="'%(Name)' == 'NoInclude' AND '%(Value)' == 'true'">-i</Value>
+      </options>
+
+      <!--//  -p <path>                   Path prefix for included file -->
+      <options>
+        <Value Condition="'%(Name)' == 'PathPrefix'">-p%(Value)</Value>
+      </options>
+
+      <!--//  -f <file>                   Force #include <file> (overwrite default) -->
+      <options>
+        <Value Condition="'%(Name)' == 'ForceInclude'">-f %(Value)</Value>
+      </options>
+
+      <!--//  -b <file>                   Prepend #include <file> (preserve default include) -->
+      <options>
+        <Value Condition="'%(Name)' == 'PrependInclude'">-b %(Value)</Value>
+      </options>
+
+      <!--//   -include <file>            Parse <file> as an #include before the main source(s) -->
+      <options>
+        <Value Condition="'%(Name)' == 'Include'">--include %(Value)</Value>
+      </options>
+
+      <!--//  -n <which>                  Do not display notes (-nn) or warnings (-nw) -->
+      <options>
+        <Value Condition="'%(Name)' == 'NoNotesWarnings'">-n%(Value)</Value>
+      </options>
+
+      <!--//   -no-notes                  Do not display notes -->
+      <options>
+        <Value Condition="'%(Name)' == 'NoNotes' AND '%(Value)' != 'true'"></Value>
+      </options>
+      <options>
+        <Value Condition="'%(Name)' == 'NoNotes' AND '%(Value)' == 'true'">--no-notes</Value>
+      </options>
+
+      <!--//   -no-warnings               Do not display warnings (implies  -no-notes) -->
+      <options>
+        <Value Condition="'%(Name)' == 'NoWarnings' AND '%(Value)' != 'true'"></Value>
+      </options>
+      <options>
+        <Value Condition="'%(Name)' == 'NoWarnings' AND '%(Value)' == 'true'">--no-warnings</Value>
+      </options>
+
+      <!--//   -ignore-option-clashes     Ignore all options that conflict with compilers -->
+      <options>
+        <Value Condition="'%(Name)' == 'IgnoreConflicts' AND '%(Value)' != 'true'"></Value>
+      </options>
+      <options>
+        <Value Condition="'%(Name)' == 'IgnoreConflicts' AND '%(Value)' == 'true'"
+          >--ignore-option-clashes</Value>
+      </options>
+
+      <!--//  [@option-file]              Read additional options from option-file-->
+      <options>
+        <Value Condition="'%(Name)' == 'OptionsFile'">@%(Value)</Value>
+      </options>
+    </ItemGroup>
+    <PropertyGroup>
+      <options>@(options->'%(Value)', ' ')</options>
+    </PropertyGroup>
+
+    <!--
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    // Aux properties
+    // -->
+    <PropertyGroup>
+      <!--// Force modified flag if source was manually selected to build -->
+      <input_changed Condition="'$(SelectedFiles)' != ''"
+        >true</input_changed>
+      <input_changed Condition="'$(SelectedFiles)' == ''"
+        >%(QtMoc.InputChanged)</input_changed>
+
+      <!--// Run work in parallel processes -->
+      <run_parallel Condition="'@(QtMoc)' != ''
+        AND '%(QtMoc.ParallelProcess)' == 'true'
+        AND '$(SelectedFiles)' == ''"
+        >true</run_parallel>
+
+      <!--// Run work in single process -->
+      <run_single Condition="'@(QtMoc)' != ''
+        AND ('%(QtMoc.ParallelProcess)' != 'true'
+         OR '$(SelectedFiles)' != '')"
+        >true</run_single>
+
+      <!--// Get relative path to output -->
+      <output_relative
+>$([MSBuild]::MakeRelative($(ProjectDir), %(QtMoc.OutputFile)).TrimStart('\'))</output_relative>
+
+      <!--// Get relative path to input -->
+      <input_relative
+>$([MSBuild]::MakeRelative($(ProjectDir), %(QtMoc.InputFile)).TrimStart('\'))</input_relative>
+    </PropertyGroup>
+
+    <!--
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    // Create work item
+    // -->
+    <ItemGroup Condition="'$(run_parallel)' == 'true' OR '$(run_single)' == 'true'">
+      <QtWork Include="@(QtMoc)">
+        <WorkType>moc</WorkType>
+        <ToolPath Condition="'$(QtVsProjectSettings)' == 'true'"
+          >$(QtToolsPath)/moc</ToolPath>
+        <ToolPath Condition="'$(QtVsProjectSettings)' != 'true'"
+          >%(QtMoc.QTDIR)\bin\moc.exe</ToolPath>
+        <Options>$(options)</Options>
+        <Message>%(QtMoc.ExecutionDescription)</Message>
+        <DependenciesChanged>$(dependencies_changed)</DependenciesChanged>
+        <InputChanged>$(input_changed)</InputChanged>
+        <ParallelBuild Condition="'$(run_parallel)' == 'true'">true</ParallelBuild>
+        <ParallelBuild Condition="'$(run_single)'   == 'true'">false</ParallelBuild>
+        <!--
+        ///////////////////////////////////////////////////////////////////////////////////////////
+        // C++ dynamic source -->
+        <ClCompile Condition="'%(QtMoc.DynamicSource)' == 'output'">$(output_relative)</ClCompile>
+        <ClCompile Condition="'%(QtMoc.DynamicSource)' ==  'input'">$(input_relative)</ClCompile>
+      </QtWork>
+    </ItemGroup>
+
+    <!--
+    ///////////////////////////////////////////////////////////////////////////////////////////////
+    // Clean-up
+    // -->
+    <PropertyGroup>
+      <options/>
+      <dependencies_changed/>
+      <input_changed/>
+      <run_parallel/>
+      <run_single/>
+      <output_relative/>
+      <input_relative/>
+    </PropertyGroup>
+    <ItemGroup>
+      <options Remove="@(options)"/>
+    </ItemGroup>
+  </Target>
+
+  <!--
+  /////////////////////////////////////////////////////////////////////////////////////////////////
+  // Import dependants
+  // -->
+  <Import
+    Condition="'$(QtMsBuildTargets_AfterMoc)' != ''"
+    Project="$(QtMsBuildTargets_AfterMoc)"/>
+
+</Project>
diff --git a/Source/VSProps/qtmoc_cl.targets b/Source/VSProps/qtmoc_cl.targets
new file mode 100644
index 0000000000..19f8d54687
--- /dev/null
+++ b/Source/VSProps/qtmoc_cl.targets
@@ -0,0 +1,49 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    *****************************************************************************
+    **
+    ** Copyright (C) 2019 The Qt Company Ltd.
+    ** Contact: https://www.qt.io/licensing/
+    **
+    ** This file is part of the Qt VS Tools.
+    **
+    ** $QT_BEGIN_LICENSE:GPL-EXCEPT$
+    ** Commercial License Usage
+    ** Licensees holding valid commercial Qt licenses may use this file in
+    ** accordance with the commercial license agreement provided with the
+    ** Software or, alternatively, in accordance with the terms contained in
+    ** a written agreement between you and The Qt Company. For licensing terms
+    ** and conditions see https://www.qt.io/terms-conditions. For further
+    ** information use the contact form at https://www.qt.io/contact-us.
+    **
+    ** GNU General Public License Usage
+    ** Alternatively, this file may be used under the terms of the GNU
+    ** General Public License version 3 as published by the Free Software
+    ** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
+    ** included in the packaging of this file. Please review the following
+    ** information to ensure the GNU General Public License requirements will
+    ** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+    **
+    ** $QT_END_LICENSE$
+    **
+    *****************************************************************************
+-->
+<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Target Name="QtMocOverrideCpp" DependsOnTargets="QtMocPrepare;QtGetDefaultClCompile"
+    Inputs="%(QtMoc.Identity)" Outputs="@(QtMoc->'####### Don't skip this target #######')">
+
+    <Message Importance="High" Condition="'$(QtDebug)' == 'true'"
+      Text="## QtMocOverrideCpp @(QtMoc)" />
+    <!--
+      NOTE: This implementation was a template, which has been manually edited
+      for dolphin-emu specific behavior (carries over defines but not includes)
+    -->
+    <ItemGroup>
+      <QtMoc>
+        <IncludePath></IncludePath>
+        <Define>%(ClCompile.PreprocessorDefinitions)</Define>
+        <Undefine></Undefine>
+      </QtMoc>
+    </ItemGroup>
+  </Target>
+</Project>