[PastePlain] Introduce Paste as Plain Text module (#23645)

* [PastePlain] Introduce Paste as Plain Text module

* fix build

* add telemetry

* update settings UI

* spell

* Add navigation items to Settings and OOBE

* Add PastePlain to the Quick Access flyout

* try to fix PastePlain not being enabled from runner/settings

* load dll properly

* installer files

* Add PastePlain project name

* Use win32 APIs in the module interface instead

* Fix spellcheck

* Fix build errors

* Add success, error and invoke telemetry

* Add Settings Telemetry

* Add GPO definitions

* Fix analyzer errors

* Use static_cast instead of reinterpret_cast

* Add images to Settings

* Add note about replacing clipboard contents

* Fix learn more text

* Add link to readme

* Remove unneeded C# app

* Fix installer

* Fix spellchecker

---------

Co-authored-by: Jaime Bernardo <jaime@janeasystems.com>

src/modules/pasteplain/PastePlainModuleInterface/PastePlain.base.rc

@@ -0,0 +1,40 @@
+#include <windows.h>
+#include "resource.h"
+#include "../../../../common/version/version.h"
+
+#define APSTUDIO_READONLY_SYMBOLS
+#include "winres.h"
+#undef APSTUDIO_READONLY_SYMBOLS
+
+1 VERSIONINFO
+FILEVERSION FILE_VERSION
+PRODUCTVERSION PRODUCT_VERSION
+FILEFLAGSMASK VS_FFI_FILEFLAGSMASK
+#ifdef _DEBUG
+FILEFLAGS VS_FF_DEBUG
+#else
+FILEFLAGS 0x0L
+#endif
+FILEOS VOS_NT_WINDOWS32
+FILETYPE VFT_DLL
+FILESUBTYPE VFT2_UNKNOWN 
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "040904b0" // US English (0x0409), Unicode (0x04B0) charset
+        BEGIN
+            VALUE "CompanyName", COMPANY_NAME
+            VALUE "FileDescription", FILE_DESCRIPTION
+            VALUE "FileVersion", FILE_VERSION_STRING
+            VALUE "InternalName", INTERNAL_NAME
+            VALUE "LegalCopyright", COPYRIGHT_NOTE
+            VALUE "OriginalFilename", ORIGINAL_FILENAME
+            VALUE "ProductName", PRODUCT_NAME
+            VALUE "ProductVersion", PRODUCT_VERSION_STRING
+        END
+    END
+    BLOCK "VarFileInfo"
+    BEGIN
+        VALUE "Translation", 0x409, 1200 // US English (0x0409), Unicode (1200) charset
+    END
+END

src/modules/pasteplain/PastePlainModuleInterface/PastePlainConstants.h

@@ -0,0 +1,8 @@
+#pragma once
+#include <string>
+
+namespace PastePlainConstants
+{
+    // Name of the powertoy module.
+    inline const std::wstring ModuleKey = L"PastePlain";
+}

src/modules/pasteplain/PastePlainModuleInterface/PastePlainModuleInterface.vcxproj

@@ -0,0 +1,85 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="..\..\..\..\packages\Microsoft.Windows.CppWinRT.2.0.220929.3\build\native\Microsoft.Windows.CppWinRT.props" Condition="Exists('..\..\..\..\packages\Microsoft.Windows.CppWinRT.2.0.220929.3\build\native\Microsoft.Windows.CppWinRT.props')" />
+  <Target Name="GenerateResourceFiles" BeforeTargets="PrepareForBuild">
+    <Exec Command="powershell -NonInteractive -executionpolicy Unrestricted $(SolutionDir)tools\build\convert-resx-to-rc.ps1 $(MSBuildThisFileDirectory) resource.base.h resource.h PastePlain.base.rc PastePlain.rc" />
+  </Target>
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>15.0</VCProjectVersion>
+    <Keyword>Win32Proj</Keyword>
+    <ProjectGuid>{FC373B24-3293-453C-AAF5-CF2909DCEE6A}</ProjectGuid>
+    <RootNamespace>PastePlain</RootNamespace>
+    <ProjectName>PastePlainModuleInterface</ProjectName>
+    <TargetName>PowerToys.PastePlainModuleInterface</TargetName>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <PlatformToolset>v143</PlatformToolset>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <OutDir>$(SolutionDir)$(Platform)\$(Configuration)\modules\PastePlain\</OutDir>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <PreprocessorDefinitions>EXAMPLEPOWERTOY_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>..\..\..\common\inc;..\..\..\common\Telemetry;..\..\;..\..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <OutputFile>$(OutDir)$(TargetName)$(TargetExt)</OutputFile>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="PastePlainConstants.h" />
+    <ClInclude Include="pch.h" />
+    <None Include="packages.config" />
+    <None Include="resource.base.h" />
+    <ClInclude Include="trace.h" />
+    <ClInclude Include="Generated Files\resource.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="dllmain.cpp" />
+    <ClCompile Include="pch.cpp">
+      <PrecompiledHeader Condition="'$(CIBuild)'!='true'">Create</PrecompiledHeader>
+    </ClCompile>
+    <ClCompile Include="trace.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\common\logger\logger.vcxproj">
+      <Project>{d9b8fc84-322a-4f9f-bbb9-20915c47ddfd}</Project>
+    </ProjectReference>
+    <ProjectReference Include="..\..\..\common\SettingsAPI\SettingsAPI.vcxproj">
+      <Project>{6955446d-23f7-4023-9bb3-8657f904af99}</Project>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="PastePlain.base.rc" />
+    <ResourceCompile Include="Generated Files\PastePlain.rc" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="Resources.resx">
+      <SubType>Designer</SubType>
+    </None>
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <Import Project="..\..\..\..\deps\spdlog.props" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="..\..\..\..\packages\Microsoft.Windows.CppWinRT.2.0.220929.3\build\native\Microsoft.Windows.CppWinRT.targets" Condition="Exists('..\..\..\..\packages\Microsoft.Windows.CppWinRT.2.0.220929.3\build\native\Microsoft.Windows.CppWinRT.targets')" />
+  </ImportGroup>
+  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
+    <PropertyGroup>
+      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
+    </PropertyGroup>
+    <Error Condition="!Exists('..\..\..\..\packages\Microsoft.Windows.CppWinRT.2.0.220929.3\build\native\Microsoft.Windows.CppWinRT.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\..\packages\Microsoft.Windows.CppWinRT.2.0.220929.3\build\native\Microsoft.Windows.CppWinRT.props'))" />
+    <Error Condition="!Exists('..\..\..\..\packages\Microsoft.Windows.CppWinRT.2.0.220929.3\build\native\Microsoft.Windows.CppWinRT.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\..\packages\Microsoft.Windows.CppWinRT.2.0.220929.3\build\native\Microsoft.Windows.CppWinRT.targets'))" />
+  </Target>
+</Project>

src/modules/pasteplain/PastePlainModuleInterface/PastePlainModuleInterface.vcxproj.filters

@@ -0,0 +1,62 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;c++;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd</Extensions>
+    </Filter>
+    <Filter Include="Resource Files">
+      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
+      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
+    </Filter>
+    <Filter Include="Generated Files">
+      <UniqueIdentifier>{875a08c6-f610-4667-bd0f-80171ed96072}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="pch.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Generated Files\resource.h">
+      <Filter>Generated Files</Filter>
+    </ClInclude>
+    <ClInclude Include="PastePlainConstants.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="trace.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="dllmain.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="pch.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="trace.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="resource.base.h">
+      <Filter>Header Files</Filter>
+    </None>
+    <None Include="Resources.resx">
+      <Filter>Resource Files</Filter>
+    </None>
+    <None Include="packages.config" />
+    <None Include="PastePlain.base.rc">
+      <Filter>Resource Files</Filter>
+    </None>
+  </ItemGroup>
+  <ItemGroup>
+    <ResourceCompile Include="Generated Files\PastePlain.rc">
+      <Filter>Resource Files</Filter>
+    </ResourceCompile>
+  </ItemGroup>
+</Project>

src/modules/pasteplain/PastePlainModuleInterface/Resources.resx

@@ -0,0 +1,126 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <data name="PastePlain_Name" xml:space="preserve">
+    <value>Paste As Plain Text</value>
+  </data>
+  <data name="PastePlain_Settings_Desc" xml:space="preserve">
+    <value>PowerToys integration to paste clipboard contents as plain text</value>
+  </data>
+</root>

src/modules/pasteplain/PastePlainModuleInterface/dllmain.cpp

@@ -0,0 +1,495 @@
+// dllmain.cpp : Defines the entry point for the DLL application.
+#include "pch.h"
+
+#include <interface/powertoy_module_interface.h>
+#include "trace.h"
+#include "Generated Files/resource.h"
+#include <common/logger/logger.h>
+#include <common/SettingsAPI/settings_objects.h>
+#include <common/utils/resources.h>
+
+#include "PastePlainConstants.h"
+#include <common/interop/shared_constants.h>
+#include <common/utils/logger_helper.h>
+#include <common/utils/winapi_error.h>
+
+BOOL APIENTRY DllMain(HMODULE /*hModule*/,
+                      DWORD ul_reason_for_call,
+                      LPVOID /*lpReserved*/)
+{
+    switch (ul_reason_for_call)
+    {
+    case DLL_PROCESS_ATTACH:
+        Trace::RegisterProvider();
+        break;
+    case DLL_THREAD_ATTACH:
+        break;
+    case DLL_THREAD_DETACH:
+        break;
+    case DLL_PROCESS_DETACH:
+        Trace::UnregisterProvider();
+        break;
+    }
+
+    return TRUE;
+}
+
+namespace
+{
+    const wchar_t JSON_KEY_PROPERTIES[] = L"properties";
+    const wchar_t JSON_KEY_WIN[] = L"win";
+    const wchar_t JSON_KEY_ALT[] = L"alt";
+    const wchar_t JSON_KEY_CTRL[] = L"ctrl";
+    const wchar_t JSON_KEY_SHIFT[] = L"shift";
+    const wchar_t JSON_KEY_CODE[] = L"code";
+    const wchar_t JSON_KEY_ACTIVATION_SHORTCUT[] = L"ActivationShortcut";
+}
+
+struct ModuleSettings
+{
+} g_settings;
+
+class PastePlain : public PowertoyModuleIface
+{
+private:
+    bool m_enabled = false;
+
+    std::wstring app_name;
+
+    //contains the non localized key of the powertoy
+    std::wstring app_key;
+
+    HANDLE m_hProcess;
+
+    // Time to wait for process to close after sending WM_CLOSE signal
+    static const int MAX_WAIT_MILLISEC = 10000;
+
+    Hotkey m_hotkey;
+
+    // Handle to event used to invoke PastePlain
+    HANDLE m_hInvokeEvent;
+
+    void parse_hotkey(PowerToysSettings::PowerToyValues& settings)
+    {
+        auto settingsObject = settings.get_raw_json();
+        if (settingsObject.GetView().Size())
+        {
+            try
+            {
+                auto jsonHotkeyObject = settingsObject.GetNamedObject(JSON_KEY_PROPERTIES).GetNamedObject(JSON_KEY_ACTIVATION_SHORTCUT);
+                m_hotkey.win = jsonHotkeyObject.GetNamedBoolean(JSON_KEY_WIN);
+                m_hotkey.alt = jsonHotkeyObject.GetNamedBoolean(JSON_KEY_ALT);
+                m_hotkey.shift = jsonHotkeyObject.GetNamedBoolean(JSON_KEY_SHIFT);
+                m_hotkey.ctrl = jsonHotkeyObject.GetNamedBoolean(JSON_KEY_CTRL);
+                m_hotkey.key = static_cast<unsigned char>(jsonHotkeyObject.GetNamedNumber(JSON_KEY_CODE));
+            }
+            catch (...)
+            {
+                Logger::error("Failed to initialize PastePlain start shortcut");
+            }
+        }
+        else
+        {
+            Logger::info("PastePlain settings are empty");
+        }
+
+        if (!m_hotkey.key)
+        {
+            Logger::info("PastePlain is going to use default shortcut");
+            m_hotkey.win = true;
+            m_hotkey.alt = false;
+            m_hotkey.shift = false;
+            m_hotkey.ctrl = true;
+            m_hotkey.key = 'V';
+        }
+    }
+
+    bool is_process_running()
+    {
+        return WaitForSingleObject(m_hProcess, 0) == WAIT_TIMEOUT;
+    }
+
+    void launch_process()
+    {
+        Logger::trace(L"Starting PastePlain process");
+        unsigned long powertoys_pid = GetCurrentProcessId();
+
+        std::wstring executable_args = L"";
+        executable_args.append(std::to_wstring(powertoys_pid));
+
+        SHELLEXECUTEINFOW sei{ sizeof(sei) };
+        sei.fMask = { SEE_MASK_NOCLOSEPROCESS | SEE_MASK_FLAG_NO_UI };
+        sei.lpFile = L"modules\\PastePlain\\PowerToys.PastePlain.exe";
+        sei.nShow = SW_SHOWNORMAL;
+        sei.lpParameters = executable_args.data();
+        if (ShellExecuteExW(&sei))
+        {
+            Logger::trace("Successfully started the PastePlain process");
+        }
+        else
+        {
+            Logger::error(L"PastePlain failed to start. {}", get_last_error_or_default(GetLastError()));
+        }
+
+        m_hProcess = sei.hProcess;
+    }
+
+    // Load the settings file.
+    void init_settings()
+    {
+        try
+        {
+            // Load and parse the settings file for this PowerToy.
+            PowerToysSettings::PowerToyValues settings =
+                PowerToysSettings::PowerToyValues::load_from_settings_file(get_key());
+
+            parse_hotkey(settings);
+        }
+        catch (std::exception&)
+        {
+            Logger::warn(L"An exception occurred while loading the settings file");
+            // Error while loading from the settings file. Let default values stay as they are.
+        }
+    }
+
+    void try_inject_modifier_key_up(std::vector<INPUT> &inputs, short modifier)
+    {
+        // Most significant bit is set if key is down
+        if ((GetAsyncKeyState(static_cast<int>(modifier)) & 0x8000) != 0)
+        {
+            INPUT input_event = {};
+            input_event.type = INPUT_KEYBOARD;
+            input_event.ki.wVk = modifier;
+            input_event.ki.dwFlags = KEYEVENTF_KEYUP;
+            inputs.push_back(input_event);
+        }
+    }
+
+    void try_to_paste_as_plain_text()
+    {
+        std::wstring clipboard_text;
+
+        {
+            // Read clipboard data begin
+
+            if (!OpenClipboard(NULL))
+            {
+                DWORD errorCode = GetLastError();
+                auto errorMessage = get_last_error_message(errorCode);
+                Logger::error(L"Couldn't open the clipboard to get the text. {}", errorMessage.has_value() ? errorMessage.value() : L"");
+                Trace::PastePlainError(errorCode, errorMessage.has_value() ? errorMessage.value() : L"", L"read.OpenClipboard");
+                return;
+            }
+            HANDLE h_clipboard_data = GetClipboardData(CF_UNICODETEXT);
+
+            if (h_clipboard_data == NULL)
+            {
+                DWORD errorCode = GetLastError();
+                auto errorMessage = get_last_error_message(errorCode);
+                Logger::error(L"Failed to get clipboard data. {}", errorMessage.has_value() ? errorMessage.value() : L"");
+                Trace::PastePlainError(errorCode, errorMessage.has_value() ? errorMessage.value() : L"", L"read.GetClipboardData");
+                CloseClipboard();
+                return;
+            }
+
+            wchar_t* pch_data= static_cast<wchar_t*>(GlobalLock(h_clipboard_data));
+
+            if (NULL == pch_data )
+            {
+                DWORD errorCode = GetLastError();
+                auto errorMessage = get_last_error_message(errorCode);
+                Logger::error(L"Couldn't lock the buffer to get the unformatted text from the clipboard. {}", errorMessage.has_value() ? errorMessage.value() : L"");
+                Trace::PastePlainError(errorCode, errorMessage.has_value() ? errorMessage.value() : L"", L"read.GlobalLock");
+                CloseClipboard();
+                return;
+            }
+
+            clipboard_text = pch_data;
+            GlobalUnlock(h_clipboard_data);
+
+            CloseClipboard();
+            // Read clipboard data end
+        }
+
+        {
+            // Copy text to clipboard begin
+            UINT no_clipboard_history_or_roaming_format = 0;
+
+            // Get the format identifier for not adding the data to the clipboard history or roaming.
+            // https://learn.microsoft.com/en-us/windows/win32/dataxchg/clipboard-formats#cloud-clipboard-and-clipboard-history-formats
+            if (0 == (no_clipboard_history_or_roaming_format = RegisterClipboardFormat(L"ExcludeClipboardContentFromMonitorProcessing")))
+            {
+                DWORD errorCode = GetLastError();
+                auto errorMessage = get_last_error_message(errorCode);
+                Logger::error(L"Couldn't get the clipboard data format type that would allow excluding the data from the clipboard history / roaming. {}", errorMessage.has_value() ? errorMessage.value() : L"");
+                Trace::PastePlainError(errorCode, errorMessage.has_value() ? errorMessage.value() : L"", L"write.RegisterClipboardFormat");
+                return;
+            }
+
+            if (!OpenClipboard(NULL))
+            {
+                DWORD errorCode = GetLastError();
+                auto errorMessage = get_last_error_message(errorCode);
+                Logger::error(L"Couldn't open the clipboard to copy the unformatted text. {}", errorMessage.has_value() ? errorMessage.value() : L"");
+                Trace::PastePlainError(errorCode, errorMessage.has_value() ? errorMessage.value() : L"", L"write.OpenClipboard");
+                return;
+            }
+
+            HGLOBAL h_clipboard_data;
+
+            if (NULL == (h_clipboard_data = GlobalAlloc(GMEM_MOVEABLE, (clipboard_text.length() + 1) * sizeof(wchar_t))))
+            {
+                DWORD errorCode = GetLastError();
+                auto errorMessage = get_last_error_message(errorCode);
+                Logger::error(L"Couldn't allocate a buffer for the unformatted text. {}", errorMessage.has_value() ? errorMessage.value() : L"");
+                Trace::PastePlainError(errorCode, errorMessage.has_value() ? errorMessage.value() : L"", L"write.GlobalAlloc");
+                CloseClipboard();
+                return;
+            }
+            wchar_t* pch_data = static_cast<wchar_t*>(GlobalLock(h_clipboard_data));
+
+            if (NULL == pch_data)
+            {
+                DWORD errorCode = GetLastError();
+                auto errorMessage = get_last_error_message(errorCode);
+                Logger::error(L"Couldn't lock the buffer to send the unformatted text to the clipboard. {}", errorMessage.has_value() ? errorMessage.value() : L"");
+                GlobalFree(h_clipboard_data);
+                CloseClipboard();
+                Trace::PastePlainError(errorCode, errorMessage.has_value() ? errorMessage.value() : L"", L"write.GlobalLock");
+                return;
+            }
+
+            wcscpy_s(pch_data, clipboard_text.length() + 1, clipboard_text.c_str());
+
+            EmptyClipboard();
+
+            if (NULL == SetClipboardData(CF_UNICODETEXT, h_clipboard_data))
+            {
+                DWORD errorCode = GetLastError();
+                auto errorMessage = get_last_error_message(errorCode);
+                Logger::error(L"Couldn't set the clipboard data to the unformatted text. {}", errorMessage.has_value() ? errorMessage.value() : L"");
+                GlobalUnlock(h_clipboard_data);
+                GlobalFree(h_clipboard_data);
+                CloseClipboard();
+                Trace::PastePlainError(errorCode, errorMessage.has_value() ? errorMessage.value() : L"", L"write.SetClipboardData");
+                return;
+            }
+
+            // Don't show in history or allow data roaming.
+            SetClipboardData(no_clipboard_history_or_roaming_format, 0);
+
+            CloseClipboard();
+            // Copy text to clipboard end
+        }
+        {
+            // Clear kb state and send Ctrl+V begin
+            
+            // we can assume that the last pressed key is...
+            //  (1) not a modifier key and
+            //  (2) marked as handled (so it never gets a key down input event).
+            // So, let's check which modifiers were pressed,
+            // and, if they were, inject a key up event for each of them
+            std::vector<INPUT> inputs;
+            try_inject_modifier_key_up(inputs, VK_LCONTROL);
+            try_inject_modifier_key_up(inputs, VK_RCONTROL);
+            try_inject_modifier_key_up(inputs, VK_LWIN);
+            try_inject_modifier_key_up(inputs, VK_RWIN);
+            try_inject_modifier_key_up(inputs, VK_LSHIFT);
+            try_inject_modifier_key_up(inputs, VK_RSHIFT);
+            try_inject_modifier_key_up(inputs, VK_LMENU);
+            try_inject_modifier_key_up(inputs, VK_RMENU);
+
+            // send Ctrl+V (key downs and key ups)
+            {
+                INPUT input_event = {};
+                input_event.type = INPUT_KEYBOARD;
+                input_event.ki.wVk = VK_CONTROL;
+                inputs.push_back(input_event);
+            }
+
+            {
+                INPUT input_event = {};
+                input_event.type = INPUT_KEYBOARD;
+                input_event.ki.wVk = 0x56; // V
+                inputs.push_back(input_event);
+            }
+
+            {
+                INPUT input_event = {};
+                input_event.type = INPUT_KEYBOARD;
+                input_event.ki.wVk = 0x56; // V
+                input_event.ki.dwFlags = KEYEVENTF_KEYUP;
+                inputs.push_back(input_event);
+            }
+
+            {
+                INPUT input_event = {};
+                input_event.type = INPUT_KEYBOARD;
+                input_event.ki.wVk = VK_CONTROL;
+                input_event.ki.dwFlags = KEYEVENTF_KEYUP;
+                inputs.push_back(input_event);
+            }
+
+            auto uSent = SendInput(static_cast<UINT>(inputs.size()), inputs.data(), sizeof(INPUT));
+            if (uSent != inputs.size())
+            {
+                DWORD errorCode = GetLastError();
+                auto errorMessage = get_last_error_message(errorCode);
+                Logger::error(L"SendInput failed. Expected to send {} inputs and sent only {}. {}", inputs.size(), uSent, errorMessage.has_value() ? errorMessage.value() : L"");
+                Trace::PastePlainError(errorCode, errorMessage.has_value() ? errorMessage.value() : L"", L"input.SendInput");
+                return;
+            }
+
+            // Clear kb state and send Ctrl+V end
+        }
+        Trace::PastePlainSuccess();
+    }
+
+public:
+    PastePlain()
+    {
+        app_name = GET_RESOURCE_STRING(IDS_PASTEPLAIN_NAME);
+        app_key = PastePlainConstants::ModuleKey;
+        LoggerHelpers::init_logger(app_key, L"ModuleInterface", "PastePlain");
+        init_settings();
+    }
+
+    ~PastePlain()
+    {
+        if (m_enabled)
+        {
+        }
+        m_enabled = false;
+    }
+
+    // Destroy the powertoy and free memory
+    virtual void destroy() override
+    {
+        Logger::trace("PastePlain::destroy()");
+        delete this;
+    }
+
+    // Return the localized display name of the powertoy
+    virtual const wchar_t* get_name() override
+    {
+        return app_name.c_str();
+    }
+
+    // Return the non localized key of the powertoy, this will be cached by the runner
+    virtual const wchar_t* get_key() override
+    {
+        return app_key.c_str();
+    }
+
+    // Return the configured status for the gpo policy for the module
+    virtual powertoys_gpo::gpo_rule_configured_t gpo_policy_enabled_configuration() override
+    {
+        return powertoys_gpo::getConfiguredPastePlainEnabledValue();
+    }
+
+    virtual bool get_config(wchar_t* buffer, int* buffer_size) override
+    {
+        HINSTANCE hinstance = reinterpret_cast<HINSTANCE>(&__ImageBase);
+
+        // Create a Settings object.
+        PowerToysSettings::Settings settings(hinstance, get_name());
+        settings.set_description(GET_RESOURCE_STRING(IDS_PASTEPLAIN_SETTINGS_DESC));
+
+        settings.set_overview_link(L"https://aka.ms/PowerToysOverview_PastePlain");
+
+        return settings.serialize_to_buffer(buffer, buffer_size);
+    }
+
+    virtual void call_custom_action(const wchar_t* /*action*/) override
+    {
+    }
+
+    virtual void set_config(const wchar_t* config) override
+    {
+        try
+        {
+            // Parse the input JSON string.
+            PowerToysSettings::PowerToyValues values =
+                PowerToysSettings::PowerToyValues::from_json_string(config, get_key());
+
+            parse_hotkey(values);
+            // If you don't need to do any custom processing of the settings, proceed
+            // to persists the values calling:
+            values.save_to_settings_file();
+            // Otherwise call a custom function to process the settings before saving them to disk:
+            // save_settings();
+        }
+        catch (std::exception&)
+        {
+            // Improper JSON.
+        }
+    }
+
+    virtual void enable()
+    {
+        Logger::trace("PastePlain::enable()");
+        m_enabled = true;
+        Trace::EnablePastePlain(true);
+    };
+
+    virtual void disable()
+    {
+        Logger::trace("PastePlain::disable()");
+        m_enabled = false;
+        Trace::EnablePastePlain(false);
+    }
+
+
+
+    virtual bool on_hotkey(size_t /*hotkeyId*/) override
+    {
+        if (m_enabled)
+        {
+            Logger::trace(L"PastePlain hotkey pressed");
+
+            std::thread([=]() {
+                // hotkey work should be kept to a minimum, or Windows might deregister our low level keyboard hook.
+                // Move work to another thread.
+                try_to_paste_as_plain_text();
+            }).detach();
+
+            Trace::PastePlainInvoked();
+            return true;
+        }
+
+        return false;
+    }
+
+    virtual size_t get_hotkeys(Hotkey* hotkeys, size_t buffer_size) override
+    {
+        if (m_hotkey.key)
+        {
+            if (hotkeys && buffer_size >= 1)
+            {
+                hotkeys[0] = m_hotkey;
+            }
+
+            return 1;
+        }
+        else
+        {
+            return 0;
+        }
+    }
+
+    virtual bool is_enabled() override
+    {
+        return m_enabled;
+    }
+
+    virtual void send_settings_telemetry() override
+    {
+        Logger::info("Send settings telemetry");
+        Trace::SettingsTelemetry(m_hotkey);
+    }
+};
+
+extern "C" __declspec(dllexport) PowertoyModuleIface* __cdecl powertoy_create()
+{
+    return new PastePlain();
+}

src/modules/pasteplain/PastePlainModuleInterface/packages.config

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="Microsoft.Windows.CppWinRT" version="2.0.220929.3" targetFramework="native" />
+</packages>

src/modules/pasteplain/PastePlainModuleInterface/pch.cpp

@@ -0,0 +1,2 @@
+#include "pch.h"
+

src/modules/pasteplain/PastePlainModuleInterface/pch.h

@@ -0,0 +1,7 @@
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#include <winrt/Windows.Foundation.h>
+#include <winrt/Windows.Foundation.Collections.h>
+#include <ProjectTelemetry.h>
+#include <shellapi.h>
+#include <Shlwapi.h>

src/modules/pasteplain/PastePlainModuleInterface/resource.base.h

@@ -0,0 +1,13 @@
+//{{NO_DEPENDENCIES}}
+// Microsoft Visual C++ generated include file.
+// Used by PowerOCR.rc
+
+//////////////////////////////
+// Non-localizable
+
+#define FILE_DESCRIPTION "PowerToys PastePlain"
+#define INTERNAL_NAME "PowerToys.PastePlainModuleInterface"
+#define ORIGINAL_FILENAME "PowerToys.PastePlainModuleInterface.dll"
+
+// Non-localizable
+//////////////////////////////

src/modules/pasteplain/PastePlainModuleInterface/trace.cpp

@@ -0,0 +1,82 @@
+#include "pch.h"
+#include "trace.h"
+
+TRACELOGGING_DEFINE_PROVIDER(
+    g_hProvider,
+    "Microsoft.PowerToys",
+    // {38e8889b-9731-53f5-e901-e8a7c1753074}
+    (0x38e8889b, 0x9731, 0x53f5, 0xe9, 0x01, 0xe8, 0xa7, 0xc1, 0x75, 0x30, 0x74),
+    TraceLoggingOptionProjectTelemetry());
+
+void Trace::RegisterProvider()
+{
+    TraceLoggingRegister(g_hProvider);
+}
+
+void Trace::UnregisterProvider()
+{
+    TraceLoggingUnregister(g_hProvider);
+}
+
+// Log if the user has PastePlain enabled or disabled
+void Trace::EnablePastePlain(const bool enabled) noexcept
+{
+    TraceLoggingWrite(
+        g_hProvider,
+        "PastePlain_EnablePastePlain",
+        ProjectTelemetryPrivacyDataTag(ProjectTelemetryTag_ProductAndServicePerformance),
+        TraceLoggingKeyword(PROJECT_KEYWORD_MEASURE),
+        TraceLoggingBoolean(enabled, "Enabled"));
+}
+
+// Log if the user has invoked PastePlain
+void Trace::PastePlainInvoked() noexcept
+{
+    TraceLoggingWrite(
+        g_hProvider,
+        "PastePlain_InvokePastePlain",
+        ProjectTelemetryPrivacyDataTag(ProjectTelemetryTag_ProductAndServicePerformance),
+        TraceLoggingKeyword(PROJECT_KEYWORD_MEASURE));
+}
+
+// Log if a PastePlain invocation has succeeded
+void Trace::PastePlainSuccess() noexcept
+{
+    TraceLoggingWrite(
+        g_hProvider,
+        "PastePlain_Success",
+        ProjectTelemetryPrivacyDataTag(ProjectTelemetryTag_ProductAndServicePerformance),
+        TraceLoggingKeyword(PROJECT_KEYWORD_MEASURE));
+}
+
+// Log if an error occurs in PastePlain
+void Trace::PastePlainError(const DWORD errorCode, std::wstring errorMessage, std::wstring methodName) noexcept
+{
+    TraceLoggingWrite(
+        g_hProvider,
+        "PastePlain_Error",
+        ProjectTelemetryPrivacyDataTag(ProjectTelemetryTag_ProductAndServicePerformance),
+        TraceLoggingKeyword(PROJECT_KEYWORD_MEASURE),
+        TraceLoggingValue(methodName.c_str(), "MethodName"),
+        TraceLoggingValue(errorCode, "ErrorCode"),
+        TraceLoggingValue(errorMessage.c_str(), "ErrorMessage"));
+}
+
+// Event to send settings telemetry.
+void Trace::SettingsTelemetry(PowertoyModuleIface::Hotkey& hotkey) noexcept
+{
+    std::wstring hotKeyStr =
+        std::wstring(hotkey.win ? L"Win + " : L"") +
+        std::wstring(hotkey.ctrl ? L"Ctrl + " : L"") +
+        std::wstring(hotkey.shift ? L"Shift + " : L"") +
+        std::wstring(hotkey.alt ? L"Alt + " : L"") +
+        std::wstring(L"VK ") + std::to_wstring(hotkey.key);
+
+    TraceLoggingWrite(
+        g_hProvider,
+        "PastePlain_Settings",
+        ProjectTelemetryPrivacyDataTag(ProjectTelemetryTag_ProductAndServicePerformance),
+        TraceLoggingKeyword(PROJECT_KEYWORD_MEASURE),
+        TraceLoggingWideString(hotKeyStr.c_str(), "HotKey")
+    );
+}

src/modules/pasteplain/PastePlainModuleInterface/trace.h

@@ -0,0 +1,24 @@
+#pragma once
+#include <interface/powertoy_module_interface.h>
+
+class Trace
+{
+public:
+    static void RegisterProvider();
+    static void UnregisterProvider();
+
+    // Log if the user has PastePlain enabled or disabled
+    static void EnablePastePlain(const bool enabled) noexcept;
+
+    // Log if the user has invoked PastePlain
+    static void PastePlainInvoked() noexcept;
+
+    // Log if a PastePlain invocation has succeeded
+    static void Trace::PastePlainSuccess() noexcept;
+
+    // Log if an error occurs in PastePlain
+    static void Trace::PastePlainError(const DWORD errorCode, std::wstring errorMessage, std::wstring methodName) noexcept;
+
+    // Event to send settings telemetry.
+    static void Trace::SettingsTelemetry(PowertoyModuleIface::Hotkey& hotkey) noexcept;
+};