Mouse Utils - Mouse Highlighter (#14496)

* New PowerToys template

* Add CppWinRt to empty PowerToy

* Add Settings reference to empty PowerToy

* Use proper output dir

* Proper WindowsTargetPlatformVersion

* Add filters to vcxproj

* Proper resource file generation

* Add MouseHighlighter proof of concept code

* Abstract implementation into a struct

* Enable module

* Disable module

* Add enable module to settings page

* Can change the hotkey in settings

* Remove remaining boilerplate code

* Add logging

* Add telemetry

* Add Oobe entry

* Add installer instructions

* Add dll to pipelines

* fix spellchecker

* Add more configurability

* Make settings a bit prettier

* Fix spellchecker

* Fix wrong default fade timers

* Fix user facing strings

* Tweak default duration values

* Fix to appear in every virtual desktop

* [Mouse Highlighter] Show highlight on mouse drag (#14529)

* [Mouse Highlighter]show pointer on mouse drag

* fix spellchecker

* [MU] UI tweaks (#14544)

* UI tweaks

* Update Resources.resw

* Updated text strings

* fix spellcheck

Co-authored-by: Laute <Niels.Laute@philips.com>

* tweak default values

* PR feedback: use wstring_view

* PR feedback: Log error on json error

* PR feedback: don't throw 1

* PR feedback: fix copy-pasta leftColor->rightColor

* PR feedback:Add another error message on exception

* PR feedback: add todo to use commons/utils/json.h

Co-authored-by: Niels Laute <niels.laute@live.nl>
Co-authored-by: Laute <Niels.Laute@philips.com>

src/modules/MouseUtils/MouseHighlighter/Directory.Build.targets

@@ -0,0 +1,5 @@
+<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Target Name="GenerateResourceFiles" BeforeTargets="PrepareForBuild">
+    <Exec Command="powershell -NonInteractive -executionpolicy Unrestricted $(SolutionDir)tools\build\convert-resx-to-rc.ps1 .\ resource.base.h resource.h MouseHighlighter.base.rc MouseHighlighter.rc" />
+  </Target>
+</Project>

src/modules/MouseUtils/MouseHighlighter/MouseHighlighter.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/MouseUtils/MouseHighlighter/MouseHighlighter.cpp

@@ -0,0 +1,443 @@
+// MouseHighlighter.cpp : Defines the entry point for the application.
+//
+
+#include "pch.h"
+#include "MouseHighlighter.h"
+#include "trace.h"
+
+#ifdef COMPOSITION
+namespace winrt
+{
+    using namespace winrt::Windows::System;
+    using namespace winrt::Windows::UI::Composition;
+}
+
+namespace ABI
+{
+    using namespace ABI::Windows::System;
+    using namespace ABI::Windows::UI::Composition::Desktop;
+}
+#endif
+
+struct Highlighter
+{
+    bool MyRegisterClass(HINSTANCE hInstance);
+    static Highlighter* instance;
+    void Terminate();
+    void SwitchActivationMode();
+    void ApplySettings(MouseHighlighterSettings settings);
+
+private:
+    enum class MouseButton
+    {
+        Left,
+        Right
+    };
+
+    void DestroyHighlighter();
+    static LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) noexcept;
+    void StartDrawing();
+    void StopDrawing();
+    bool CreateHighlighter();
+    void AddDrawingPoint(MouseButton button);
+    void UpdateDrawingPointPosition(MouseButton button);
+    void StartDrawingPointFading(MouseButton button);
+    void ClearDrawing();
+    HHOOK m_mouseHook = NULL;
+    static LRESULT CALLBACK MouseHookProc(int nCode, WPARAM wParam, LPARAM lParam) noexcept;
+
+    static constexpr auto m_className = L"MouseHighlighter";
+    static constexpr auto m_windowTitle = L"MouseHighlighter";
+    HWND m_hwndOwner = NULL;
+    HWND m_hwnd = NULL;
+    HINSTANCE m_hinstance = NULL;
+    static constexpr DWORD WM_SWITCH_ACTIVATION_MODE = WM_APP;
+
+    winrt::DispatcherQueueController m_dispatcherQueueController{ nullptr };
+    winrt::Compositor m_compositor{ nullptr };
+    winrt::Desktop::DesktopWindowTarget m_target{ nullptr };
+    winrt::ContainerVisual m_root{ nullptr };
+    winrt::LayerVisual m_layer{ nullptr };
+    winrt::ShapeVisual m_shape{ nullptr };
+
+    winrt::CompositionSpriteShape m_leftPointer{ nullptr };
+    winrt::CompositionSpriteShape m_rightPointer{ nullptr };
+    bool m_leftButtonPressed = false;
+    bool m_rightButtonPressed = false;
+
+    bool m_visible = false;
+
+    // Possible configurable settings
+    float m_radius = MOUSE_HIGHLIGHTER_DEFAULT_RADIUS;
+
+    int m_fadeDelay_ms = MOUSE_HIGHLIGHTER_DEFAULT_DELAY_MS;
+    int m_fadeDuration_ms = MOUSE_HIGHLIGHTER_DEFAULT_DURATION_MS;
+
+    winrt::Windows::UI::Color m_leftClickColor = MOUSE_HIGHLIGHTER_DEFAULT_LEFT_BUTTON_COLOR;
+    winrt::Windows::UI::Color m_rightClickColor = MOUSE_HIGHLIGHTER_DEFAULT_RIGHT_BUTTON_COLOR;
+};
+
+Highlighter* Highlighter::instance = nullptr;
+
+bool Highlighter::CreateHighlighter()
+{
+    try
+    {
+        // We need a dispatcher queue.
+        DispatcherQueueOptions options =
+        {
+            sizeof(options),
+            DQTYPE_THREAD_CURRENT,
+            DQTAT_COM_ASTA,
+        };
+        ABI::IDispatcherQueueController* controller;
+        winrt::check_hresult(CreateDispatcherQueueController(options, &controller));
+        *winrt::put_abi(m_dispatcherQueueController) = controller;
+
+        // Create the compositor for our window.
+        m_compositor = winrt::Compositor();
+        ABI::IDesktopWindowTarget* target;
+        winrt::check_hresult(m_compositor.as<ABI::ICompositorDesktopInterop>()->CreateDesktopWindowTarget(m_hwnd, false, &target));
+        *winrt::put_abi(m_target) = target;
+
+        // Create visual root
+        m_root = m_compositor.CreateContainerVisual();
+        m_root.RelativeSizeAdjustment({ 1.0f, 1.0f });
+        m_target.Root(m_root);
+
+        // Create the shapes container visual and add it to root.
+        m_shape = m_compositor.CreateShapeVisual();
+        m_shape.RelativeSizeAdjustment({ 1.0f, 1.0f });
+        m_root.Children().InsertAtTop(m_shape);
+
+        return true;
+    } catch (...)
+    {
+        return false;
+    }
+}
+
+
+void Highlighter::AddDrawingPoint(MouseButton button)
+{
+    POINT pt;
+        
+    // Applies DPIs.
+    GetCursorPos(&pt);
+
+    // Converts to client area of the Windows.
+    ScreenToClient(m_hwnd, &pt);
+
+    // Create circle and add it.
+    auto circleGeometry = m_compositor.CreateEllipseGeometry();
+    circleGeometry.Radius({ m_radius, m_radius });
+    auto circleShape = m_compositor.CreateSpriteShape(circleGeometry);
+    circleShape.Offset({ (float)pt.x, (float)pt.y });
+    if (button == MouseButton::Left)
+    {
+        circleShape.FillBrush(m_compositor.CreateColorBrush(m_leftClickColor));
+        m_leftPointer = circleShape;
+    }
+    else
+    {
+        //right
+        circleShape.FillBrush(m_compositor.CreateColorBrush(m_rightClickColor));
+        m_rightPointer = circleShape;
+    }
+    m_shape.Shapes().Append(circleShape);
+
+    // TODO: We're leaking shapes for long drawing sessions.
+    // Perhaps add a task to the Dispatcher every X circles to clean up.
+
+    // Get back on top in case other Window is now the topmost.
+    SetWindowPos(m_hwnd, HWND_TOPMOST, GetSystemMetrics(SM_XVIRTUALSCREEN), GetSystemMetrics(SM_YVIRTUALSCREEN),
+        GetSystemMetrics(SM_CXVIRTUALSCREEN), GetSystemMetrics(SM_CYVIRTUALSCREEN), 0);
+}
+
+void Highlighter::UpdateDrawingPointPosition(MouseButton button)
+{
+    POINT pt;
+
+    // Applies DPIs.
+    GetCursorPos(&pt);
+
+    // Converts to client area of the Windows.
+    ScreenToClient(m_hwnd, &pt);
+
+    if (button == MouseButton::Left)
+    {
+        m_leftPointer.Offset({ (float)pt.x, (float)pt.y });
+    }
+    else
+    {
+        //right
+        m_rightPointer.Offset({ (float)pt.x, (float)pt.y });
+    }
+}
+void Highlighter::StartDrawingPointFading(MouseButton button)
+{
+    winrt::Windows::UI::Composition::CompositionSpriteShape circleShape{ nullptr };
+    if (button == MouseButton::Left)
+    {
+        circleShape = m_leftPointer;
+    }
+    else
+    {
+        //right
+        circleShape = m_rightPointer;
+    }
+
+    auto brushColor = circleShape.FillBrush().as<winrt::Windows::UI::Composition::CompositionColorBrush>().Color();
+
+    // Animate opacity to simulate a fade away effect.
+    auto animation = m_compositor.CreateColorKeyFrameAnimation();
+    animation.InsertKeyFrame(1, winrt::Windows::UI::ColorHelper::FromArgb(0, brushColor.R, brushColor.G, brushColor.B));
+    using timeSpan = std::chrono::duration<int, std::ratio<1, 1000>>;
+    std::chrono::milliseconds duration(m_fadeDuration_ms);
+    std::chrono::milliseconds delay(m_fadeDelay_ms);
+    animation.Duration(timeSpan(duration));
+    animation.DelayTime(timeSpan(delay));
+
+    circleShape.FillBrush().StartAnimation(L"Color", animation);
+}
+
+
+void Highlighter::ClearDrawing()
+{
+    m_shape.Shapes().Clear();
+}
+
+LRESULT CALLBACK Highlighter::MouseHookProc(int nCode, WPARAM wParam, LPARAM lParam) noexcept
+{
+    if (nCode >= 0)
+    {
+        MSLLHOOKSTRUCT* hookData = (MSLLHOOKSTRUCT*)lParam;
+        switch (wParam)
+        {
+        case WM_LBUTTONDOWN:
+            instance->AddDrawingPoint(MouseButton::Left);
+            instance->m_leftButtonPressed = true;
+            break;
+        case WM_RBUTTONDOWN:
+            instance->AddDrawingPoint(MouseButton::Right);
+            instance->m_rightButtonPressed = true;
+            break;
+        case WM_MOUSEMOVE:
+            if (instance->m_leftButtonPressed)
+            {
+                instance->UpdateDrawingPointPosition(MouseButton::Left);
+            }
+            if (instance->m_rightButtonPressed)
+            {
+                instance->UpdateDrawingPointPosition(MouseButton::Right);
+            }
+            break;
+        case WM_LBUTTONUP:
+            if (instance->m_leftButtonPressed)
+            {
+                instance->StartDrawingPointFading(MouseButton::Left);
+                instance->m_leftButtonPressed = false;
+            }
+            break;
+        case WM_RBUTTONUP:
+            if (instance->m_rightButtonPressed)
+            {
+                instance->StartDrawingPointFading(MouseButton::Right);
+                instance->m_rightButtonPressed = false;
+            }
+            break;
+        default:
+            break;
+        }
+    }
+    return CallNextHookEx(0, nCode, wParam, lParam);
+}
+
+
+void Highlighter::StartDrawing()
+{
+    Logger::info("Starting draw mode.");
+    Trace::StartHighlightingSession();
+    m_visible = true;
+    SetWindowPos(m_hwnd, HWND_TOPMOST, GetSystemMetrics(SM_XVIRTUALSCREEN), GetSystemMetrics(SM_YVIRTUALSCREEN),
+        GetSystemMetrics(SM_CXVIRTUALSCREEN), GetSystemMetrics(SM_CYVIRTUALSCREEN), 0);
+    ClearDrawing();
+    ShowWindow(m_hwnd, SW_SHOWNOACTIVATE);
+    m_mouseHook = SetWindowsHookEx(WH_MOUSE_LL, MouseHookProc, m_hinstance, 0);
+}
+
+void Highlighter::StopDrawing()
+{
+    Logger::info("Stopping draw mode.");
+    m_visible = false;
+    m_leftButtonPressed = false;
+    m_rightButtonPressed = false;
+    m_leftPointer = nullptr;
+    m_rightPointer = nullptr;
+    ShowWindow(m_hwnd, SW_HIDE);
+    UnhookWindowsHookEx(m_mouseHook);
+    ClearDrawing();
+    m_mouseHook = NULL;
+}
+
+void Highlighter::SwitchActivationMode()
+{
+    PostMessage(m_hwnd, WM_SWITCH_ACTIVATION_MODE, 0, 0);
+}
+
+void Highlighter::ApplySettings(MouseHighlighterSettings settings) {
+    m_radius = (float)settings.radius;
+    m_fadeDelay_ms = settings.fadeDelayMs;
+    m_fadeDuration_ms = settings.fadeDurationMs;
+    m_leftClickColor = settings.leftButtonColor;
+    m_rightClickColor = settings.rightButtonColor;
+}
+
+void Highlighter::DestroyHighlighter()
+{
+    StopDrawing();
+    PostQuitMessage(0);
+}
+
+LRESULT CALLBACK Highlighter::WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) noexcept
+{
+    switch (message)
+    {
+    case WM_NCCREATE:
+        instance->m_hwnd = hWnd;
+        return DefWindowProc(hWnd, message, wParam, lParam);
+    case WM_CREATE:
+        return instance->CreateHighlighter() ? 0 : -1;
+    case WM_NCHITTEST:
+        return HTTRANSPARENT;
+    case WM_SWITCH_ACTIVATION_MODE:
+        if (instance->m_visible)
+        {
+            instance->StopDrawing();
+        }
+        else
+        {
+            instance->StartDrawing();
+        }
+        break;
+    case WM_DESTROY:
+        instance->DestroyHighlighter();
+        break;
+    default:
+        return DefWindowProc(hWnd, message, wParam, lParam);
+    }
+    return 0;
+}
+
+bool Highlighter::MyRegisterClass(HINSTANCE hInstance)
+{
+    WNDCLASS wc{};
+
+    m_hinstance = hInstance;
+
+    SetThreadDpiAwarenessContext(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);
+    if (!GetClassInfoW(hInstance, m_className, &wc))
+    {
+        wc.lpfnWndProc = WndProc;
+        wc.hInstance = hInstance;
+        wc.hIcon = LoadIcon(hInstance, IDI_APPLICATION);
+        wc.hCursor = LoadCursor(nullptr, IDC_ARROW);
+        wc.hbrBackground = (HBRUSH)GetStockObject(NULL_BRUSH);
+        wc.lpszClassName = m_className;
+
+        if (!RegisterClassW(&wc))
+        {
+            return false;
+        }
+    }
+
+    m_hwndOwner = CreateWindow(L"static", nullptr, WS_POPUP, 0, 0, 0, 0, nullptr, nullptr, hInstance, nullptr);
+
+    DWORD exStyle = WS_EX_TRANSPARENT | WS_EX_LAYERED | WS_EX_NOREDIRECTIONBITMAP | WS_EX_TOOLWINDOW;
+    return CreateWindowExW(exStyle, m_className, m_windowTitle, WS_POPUP,
+        CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, m_hwndOwner, nullptr, hInstance, nullptr) != nullptr;
+}
+
+void Highlighter::Terminate()
+{
+    auto dispatcherQueue = m_dispatcherQueueController.DispatcherQueue();
+    bool enqueueSucceeded = dispatcherQueue.TryEnqueue([=]() {
+        DestroyWindow(m_hwndOwner);
+    });
+    if (!enqueueSucceeded)
+    {
+        Logger::error("Couldn't enqueue message to destroy the window.");
+    }
+}
+
+#pragma region MouseHighlighter_API
+
+void MouseHighlighterApplySettings(MouseHighlighterSettings settings)
+{
+    if (Highlighter::instance != nullptr)
+    {
+        Logger::info("Applying settings.");
+        Highlighter::instance->ApplySettings(settings);
+    }
+}
+
+void MouseHighlighterSwitch()
+{
+    if (Highlighter::instance != nullptr)
+    {
+        Logger::info("Switching activation mode.");
+        Highlighter::instance->SwitchActivationMode();
+    }
+}
+
+void MouseHighlighterDisable()
+{
+    if (Highlighter::instance != nullptr)
+    {
+        Logger::info("Terminating the highlighter instance.");
+        Highlighter::instance->Terminate();
+    }
+}
+
+bool MouseHighlighterIsEnabled()
+{
+    return (Highlighter::instance != nullptr);
+}
+
+int MouseHighlighterMain(HINSTANCE hInstance, MouseHighlighterSettings settings)
+{
+    Logger::info("Starting a highlighter instance.");
+    if (Highlighter::instance != nullptr)
+    {
+        Logger::error("A highlighter instance was still working when trying to start a new one.");
+        return 0;
+    }
+
+    // Perform application initialization:
+    Highlighter highlighter;
+    Highlighter::instance = &highlighter;
+    highlighter.ApplySettings(settings);
+    if (!highlighter.MyRegisterClass(hInstance))
+    {
+        Logger::error("Couldn't initialize a highlighter instance.");
+        Highlighter::instance = nullptr;
+        return FALSE;
+    }
+    Logger::info("Initialized the highlighter instance.");
+
+    MSG msg;
+
+    // Main message loop:
+    while (GetMessage(&msg, nullptr, 0, 0))
+    {
+        TranslateMessage(&msg);
+        DispatchMessage(&msg);
+    }
+
+    Logger::info("Mouse highlighter message loop ended.");
+    Highlighter::instance = nullptr;
+
+    return (int)msg.wParam;
+}
+
+#pragma endregion MouseHighlighter_API

src/modules/MouseUtils/MouseHighlighter/MouseHighlighter.h

@@ -0,0 +1,24 @@
+#pragma once
+#include "pch.h"
+
+constexpr int MOUSE_HIGHLIGHTER_DEFAULT_OPACITY = 160;
+const winrt::Windows::UI::Color MOUSE_HIGHLIGHTER_DEFAULT_LEFT_BUTTON_COLOR = winrt::Windows::UI::ColorHelper::FromArgb(MOUSE_HIGHLIGHTER_DEFAULT_OPACITY, 255, 255, 0);
+const winrt::Windows::UI::Color MOUSE_HIGHLIGHTER_DEFAULT_RIGHT_BUTTON_COLOR = winrt::Windows::UI::ColorHelper::FromArgb(MOUSE_HIGHLIGHTER_DEFAULT_OPACITY, 0, 0, 255);
+constexpr int MOUSE_HIGHLIGHTER_DEFAULT_RADIUS = 20;
+constexpr int MOUSE_HIGHLIGHTER_DEFAULT_DELAY_MS = 500;
+constexpr int MOUSE_HIGHLIGHTER_DEFAULT_DURATION_MS = 250;
+
+struct MouseHighlighterSettings
+{
+    winrt::Windows::UI::Color leftButtonColor = MOUSE_HIGHLIGHTER_DEFAULT_LEFT_BUTTON_COLOR;
+    winrt::Windows::UI::Color rightButtonColor = MOUSE_HIGHLIGHTER_DEFAULT_RIGHT_BUTTON_COLOR;
+    int radius = MOUSE_HIGHLIGHTER_DEFAULT_RADIUS;
+    int fadeDelayMs = MOUSE_HIGHLIGHTER_DEFAULT_DELAY_MS;
+    int fadeDurationMs = MOUSE_HIGHLIGHTER_DEFAULT_DURATION_MS;
+};
+
+int MouseHighlighterMain(HINSTANCE hinst, MouseHighlighterSettings settings);
+void MouseHighlighterDisable();
+bool MouseHighlighterIsEnabled();
+void MouseHighlighterSwitch();
+void MouseHighlighterApplySettings(MouseHighlighterSettings settings);

src/modules/MouseUtils/MouseHighlighter/MouseHighlighter.vcxproj

@@ -0,0 +1,145 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="..\..\..\..\packages\Microsoft.Windows.CppWinRT.2.0.200729.8\build\native\Microsoft.Windows.CppWinRT.props" Condition="Exists('..\..\..\..\packages\Microsoft.Windows.CppWinRT.2.0.200729.8\build\native\Microsoft.Windows.CppWinRT.props')" />
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>15.0</VCProjectVersion>
+    <ProjectGuid>{782a61be-9d85-4081-b35c-1ccc9dcc1e88}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>MouseHighlighter</RootNamespace>
+    <WindowsTargetPlatformVersion>10.0.18362.0</WindowsTargetPlatformVersion>
+    <ProjectName>MouseHighlighter</ProjectName>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v142</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v142</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>true</LinkIncremental>
+    <OutDir>$(SolutionDir)$(Platform)\$(Configuration)\modules\MouseUtils\</OutDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <LinkIncremental>false</LinkIncremental>
+    <OutDir>$(SolutionDir)$(Platform)\$(Configuration)\modules\MouseUtils\</OutDir>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>_DEBUG;_WINDOWS;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+      <LanguageStandard>stdcpplatest</LanguageStandard>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <OutputFile>$(OutDir)$(TargetName)$(TargetExt)</OutputFile>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>NDEBUG;_WINDOWS;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <LanguageStandard>stdcpplatest</LanguageStandard>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <OutputFile>$(OutDir)$(TargetName)$(TargetExt)</OutputFile>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <AdditionalIncludeDirectories>$(SolutionDir)src\;$(SolutionDir)src\modules;$(SolutionDir)src\common\Telemetry;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(CIBuild)'!='true'">
+    <ClCompile>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="MouseHighlighter.h" />
+    <ClInclude Include="pch.h" />
+    <ClInclude Include="trace.h" />
+    <ClInclude Include="Generated Files\resource.h" />
+    <None Include="resource.base.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="dllmain.cpp" />
+    <ClCompile Include="MouseHighlighter.cpp" />
+    <ClCompile Include="pch.cpp">
+      <PrecompiledHeader Condition="'$(CIBuild)'!='true'">Create</PrecompiledHeader>
+    </ClCompile>
+    <ClCompile Include="trace.cpp" />
+    <None Include="MouseHighlighter.base.rc" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config" />
+  </ItemGroup>
+  <ItemGroup>
+    <ResourceCompile Include="Generated Files\MouseHighlighter.rc" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\common\logger\logger.vcxproj">
+      <Project>{d9b8fc84-322a-4f9f-bbb9-20915c47ddfd}</Project>
+    </ProjectReference>
+    <ProjectReference Include="..\..\..\common\SettingsAPI\SetttingsAPI.vcxproj">
+      <Project>{6955446d-23f7-4023-9bb3-8657f904af99}</Project>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <Import Project="..\..\..\..\deps\spdlog.props" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="..\..\..\..\packages\Microsoft.Windows.CppWinRT.2.0.200729.8\build\native\Microsoft.Windows.CppWinRT.targets" Condition="Exists('..\..\..\..\packages\Microsoft.Windows.CppWinRT.2.0.200729.8\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.200729.8\build\native\Microsoft.Windows.CppWinRT.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\..\packages\Microsoft.Windows.CppWinRT.2.0.200729.8\build\native\Microsoft.Windows.CppWinRT.props'))" />
+    <Error Condition="!Exists('..\..\..\..\packages\Microsoft.Windows.CppWinRT.2.0.200729.8\build\native\Microsoft.Windows.CppWinRT.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\..\packages\Microsoft.Windows.CppWinRT.2.0.200729.8\build\native\Microsoft.Windows.CppWinRT.targets'))" />
+  </Target>
+</Project>

src/modules/MouseUtils/MouseHighlighter/MouseHighlighter.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>
+    <ClCompile Include="trace.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="pch.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="dllmain.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="MouseHighlighter.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="pch.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="trace.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Generated Files\resource.h">
+      <Filter>Generated Files</Filter>
+    </ClInclude>
+    <ClInclude Include="MouseHighlighter.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config" />
+    <None Include="MouseHighlighter.base.rc">
+      <Filter>Resource Files</Filter>
+    </None>
+    <None Include="resource.base.h">
+      <Filter>Resource Files</Filter>
+    </None>
+  </ItemGroup>
+  <ItemGroup>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{b012a2c8-5ccb-47fc-9429-4ebf877928e2}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;c++;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{c8345550-9836-40a0-b473-0f4bf6129568}</UniqueIdentifier>
+      <Extensions>h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd</Extensions>
+    </Filter>
+    <Filter Include="Resource Files">
+      <UniqueIdentifier>{7934ee5b-8427-486d-9324-73b6bcf60eed}</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>{e1083d6b-b856-42a6-bd1f-1710e96170ba}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ResourceCompile Include="Generated Files\MouseHighlighter.rc">
+      <Filter>Generated Files</Filter>
+    </ResourceCompile>
+  </ItemGroup>
+</Project>

src/modules/MouseUtils/MouseHighlighter/dllmain.cpp

@@ -0,0 +1,323 @@
+#include "pch.h"
+#include <interface/powertoy_module_interface.h>
+#include <common/SettingsAPI/settings_objects.h>
+#include "trace.h"
+#include "MouseHighlighter.h"
+
+namespace
+{
+    const wchar_t JSON_KEY_PROPERTIES[] = L"properties";
+    const wchar_t JSON_KEY_VALUE[] = L"value";
+    const wchar_t JSON_KEY_ACTIVATION_SHORTCUT[] = L"activation_shortcut";
+    const wchar_t JSON_KEY_LEFT_BUTTON_CLICK_COLOR[] = L"left_button_click_color";
+    const wchar_t JSON_KEY_RIGHT_BUTTON_CLICK_COLOR[] = L"right_button_click_color";
+    const wchar_t JSON_KEY_HIGHLIGHT_OPACITY[] = L"highlight_opacity";
+    const wchar_t JSON_KEY_HIGHLIGHT_RADIUS[] = L"highlight_radius";
+    const wchar_t JSON_KEY_HIGHLIGHT_FADE_DELAY_MS[] = L"highlight_fade_delay_ms";
+    const wchar_t JSON_KEY_HIGHLIGHT_FADE_DURATION_MS[] = L"highlight_fade_duration_ms";
+}
+
+extern "C" IMAGE_DOS_HEADER __ImageBase;
+
+HMODULE m_hModule;
+
+BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserved)
+{
+    m_hModule = hModule;
+    switch (ul_reason_for_call)
+    {
+    case DLL_PROCESS_ATTACH:
+        Trace::RegisterProvider();
+        break;
+    case DLL_THREAD_ATTACH:
+    case DLL_THREAD_DETACH:
+        break;
+    case DLL_PROCESS_DETACH:
+        Trace::UnregisterProvider();
+        break;
+    }
+    return TRUE;
+}
+
+// The PowerToy name that will be shown in the settings.
+const static wchar_t* MODULE_NAME = L"MouseHighlighter";
+// Add a description that will we shown in the module settings page.
+const static wchar_t* MODULE_DESC = L"<no description>";
+
+// Implement the PowerToy Module Interface and all the required methods.
+class MouseHighlighter : public PowertoyModuleIface
+{
+private:
+    // The PowerToy state.
+    bool m_enabled = false;
+
+    // Hotkey to invoke the module
+    HotkeyEx m_hotkey;
+
+    // Mouse Highlighter specific settings
+    MouseHighlighterSettings m_highlightSettings;
+
+    // helper function to get the RGB from a #FFFFFF string.
+    bool checkValidRGB(std::wstring_view hex, uint8_t* R, uint8_t* G, uint8_t* B)
+    {
+        if (hex.length() != 7)
+            return false;
+        hex = hex.substr(1, 6); // remove #
+        for (auto& c : hex)
+        {
+            if (!((c >= '0' && c <= '9') || (c >= 'A' && c <= 'F')))
+            {
+                return false;
+            }
+        }
+        if (swscanf_s(hex.data(), L"%2hhx%2hhx%2hhx", R, G, B) != 3)
+        {
+            return false;
+        }
+        return true;
+    }
+
+public:
+    // Constructor
+    MouseHighlighter()
+    {
+        LoggerHelpers::init_logger(MODULE_NAME, L"ModuleInterface", LogSettings::mouseHighlighterLoggerName);
+        init_settings();
+    };
+
+    // Destroy the powertoy and free memory
+    virtual void destroy() override
+    {
+        delete this;
+    }
+
+    // Return the localized display name of the powertoy
+    virtual const wchar_t* get_name() override
+    {
+        return MODULE_NAME;
+    }
+
+    // Return the non localized key of the powertoy, this will be cached by the runner
+    virtual const wchar_t* get_key() override
+    {
+        return MODULE_NAME;
+    }
+
+    // Return JSON with the configuration options.
+    virtual bool get_config(wchar_t* buffer, int* buffer_size) override
+    {
+        HINSTANCE hinstance = reinterpret_cast<HINSTANCE>(&__ImageBase);
+        PowerToysSettings::Settings settings(hinstance, get_name());
+        return settings.serialize_to_buffer(buffer, buffer_size);
+    }
+
+    // Signal from the Settings editor to call a custom action.
+    // This can be used to spawn more complex editors.
+    virtual void call_custom_action(const wchar_t* action) override
+    {
+    }
+
+    // Called by the runner to pass the updated settings values as a serialized JSON.
+    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_settings(values);
+
+            MouseHighlighterApplySettings(m_highlightSettings);
+        }
+        catch (std::exception&)
+        {
+            Logger::error("Invalid json when trying to parse Mouse Highlighter settings json.");
+        }
+    }
+
+    // Enable the powertoy
+    virtual void enable()
+    {
+        m_enabled = true;
+        Trace::EnableMouseHighlighter(true);
+        std::thread([=]() { MouseHighlighterMain(m_hModule, m_highlightSettings); }).detach();
+    }
+
+    // Disable the powertoy
+    virtual void disable()
+    {
+        m_enabled = false;
+        Trace::EnableMouseHighlighter(false);
+        MouseHighlighterDisable();
+    }
+
+    // Returns if the powertoys is enabled
+    virtual bool is_enabled() override
+    {
+        return m_enabled;
+    }
+
+    virtual std::optional<HotkeyEx> GetHotkeyEx() override
+    {
+        return m_hotkey;
+    }
+
+    virtual void OnHotkeyEx() override
+    {
+        MouseHighlighterSwitch();
+    }
+
+    // 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(MouseHighlighter::get_key());
+            parse_settings(settings);
+        }
+        catch (std::exception&)
+        {
+            Logger::error("Invalid json when trying to load the Mouse Highlighter settings json from file.");
+        }
+    }
+
+    void parse_settings(PowerToysSettings::PowerToyValues& settings)
+    {
+        // TODO: refactor to use common/utils/json.h instead
+        auto settingsObject = settings.get_raw_json();
+        MouseHighlighterSettings highlightSettings;
+        if (settingsObject.GetView().Size())
+        {
+            try
+            {
+                // Parse HotKey
+                auto jsonPropertiesObject = settingsObject.GetNamedObject(JSON_KEY_PROPERTIES).GetNamedObject(JSON_KEY_ACTIVATION_SHORTCUT);
+                auto hotkey = PowerToysSettings::HotkeyObject::from_json(jsonPropertiesObject);
+                m_hotkey = HotkeyEx();
+                if (hotkey.win_pressed())
+                {
+                    m_hotkey.modifiersMask |= MOD_WIN;
+                }
+
+                if (hotkey.ctrl_pressed())
+                {
+                    m_hotkey.modifiersMask |= MOD_CONTROL;
+                }
+
+                if (hotkey.shift_pressed())
+                {
+                    m_hotkey.modifiersMask |= MOD_SHIFT;
+                }
+
+                if (hotkey.alt_pressed())
+                {
+                    m_hotkey.modifiersMask |= MOD_ALT;
+                }
+
+                m_hotkey.vkCode = hotkey.get_code();
+            }
+            catch (...)
+            {
+                Logger::warn("Failed to initialize Mouse Highlighter activation shortcut");
+            }
+            uint8_t opacity = MOUSE_HIGHLIGHTER_DEFAULT_OPACITY;
+            try
+            {
+                // Parse Opacity
+                auto jsonPropertiesObject = settingsObject.GetNamedObject(JSON_KEY_PROPERTIES).GetNamedObject(JSON_KEY_HIGHLIGHT_OPACITY);
+                opacity = (uint8_t)jsonPropertiesObject.GetNamedNumber(JSON_KEY_VALUE);
+            }
+            catch (...)
+            {
+                Logger::warn("Failed to initialize Opacity from settings. Will use default value");
+            }
+            try
+            {
+                // Parse left button click color
+                auto jsonPropertiesObject = settingsObject.GetNamedObject(JSON_KEY_PROPERTIES).GetNamedObject(JSON_KEY_LEFT_BUTTON_CLICK_COLOR);
+                auto leftColor = (std::wstring)jsonPropertiesObject.GetNamedString(JSON_KEY_VALUE);
+                uint8_t r, g, b;
+                if (!checkValidRGB(leftColor,&r,&g,&b))
+                {
+                    Logger::error("Left click color RGB value is invalid. Will use default value");
+                }
+                else
+                {
+                    highlightSettings.leftButtonColor = winrt::Windows::UI::ColorHelper::FromArgb(opacity, r, g, b);
+                }
+            }
+            catch (...)
+            {
+                Logger::warn("Failed to initialize left click color from settings. Will use default value");
+            }
+            try
+            {
+                // Parse right button click color
+                auto jsonPropertiesObject = settingsObject.GetNamedObject(JSON_KEY_PROPERTIES).GetNamedObject(JSON_KEY_RIGHT_BUTTON_CLICK_COLOR);
+                auto rightColor = (std::wstring)jsonPropertiesObject.GetNamedString(JSON_KEY_VALUE);
+                uint8_t r, g, b;
+                if (!checkValidRGB(rightColor, &r, &g, &b))
+                {
+                    Logger::error("Right click color RGB value is invalid. Will use default value");
+                }
+                else
+                {
+                    highlightSettings.rightButtonColor = winrt::Windows::UI::ColorHelper::FromArgb(opacity, r, g, b);
+                }
+            }
+            catch (...)
+            {
+                Logger::warn("Failed to initialize right click color from settings. Will use default value");
+            }
+            try
+            {
+                // Parse Radius
+                auto jsonPropertiesObject = settingsObject.GetNamedObject(JSON_KEY_PROPERTIES).GetNamedObject(JSON_KEY_HIGHLIGHT_RADIUS);
+                highlightSettings.radius = (UINT)jsonPropertiesObject.GetNamedNumber(JSON_KEY_VALUE);
+            }
+            catch (...)
+            {
+                Logger::warn("Failed to initialize Radius from settings. Will use default value");
+            }
+            try
+            {
+                // Parse Fade Delay
+                auto jsonPropertiesObject = settingsObject.GetNamedObject(JSON_KEY_PROPERTIES).GetNamedObject(JSON_KEY_HIGHLIGHT_FADE_DELAY_MS);
+                highlightSettings.fadeDelayMs = (UINT)jsonPropertiesObject.GetNamedNumber(JSON_KEY_VALUE);
+            }
+            catch (...)
+            {
+                Logger::warn("Failed to initialize Fade Delay from settings. Will use default value");
+            }
+            try
+            {
+                // Parse Fade Duration
+                auto jsonPropertiesObject = settingsObject.GetNamedObject(JSON_KEY_PROPERTIES).GetNamedObject(JSON_KEY_HIGHLIGHT_FADE_DURATION_MS);
+                highlightSettings.fadeDurationMs = (UINT)jsonPropertiesObject.GetNamedNumber(JSON_KEY_VALUE);
+            }
+            catch (...)
+            {
+                Logger::warn("Failed to initialize Fade Duration from settings. Will use default value");
+            }
+        }
+        else
+        {
+            Logger::info("Mouse Highlighter settings are empty");
+        }
+        if (!m_hotkey.modifiersMask)
+        {
+            Logger::info("Mouse Highlighter is going to use default shortcut");
+            m_hotkey.modifiersMask = MOD_SHIFT | MOD_WIN;
+            m_hotkey.vkCode = 0x48; // H key
+        }
+        m_highlightSettings = highlightSettings;
+    }
+};
+
+extern "C" __declspec(dllexport) PowertoyModuleIface* __cdecl powertoy_create()
+{
+    return new MouseHighlighter();
+}

src/modules/MouseUtils/MouseHighlighter/packages.config

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

src/modules/MouseUtils/MouseHighlighter/pch.cpp

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

src/modules/MouseUtils/MouseHighlighter/pch.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#define COMPOSITION
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#include <strsafe.h>
+#include <hIdUsage.h>
+#include <thread>
+
+#ifdef COMPOSITION
+#include <windows.ui.composition.interop.h>
+#include <DispatcherQueue.h>
+#include <winrt/Windows.System.h>
+#include <winrt/Windows.Foundation.h>
+#include <winrt/Windows.UI.Composition.Desktop.h>
+#include <winrt/Windows.Foundation.Collections.h>
+#endif
+
+#include <ProjectTelemetry.h>
+#include <common/SettingsAPI/settings_helpers.h>
+#include <common/logger/logger.h>
+#include <common/utils/logger_helper.h>

src/modules/MouseUtils/MouseHighlighter/resource.base.h

@@ -0,0 +1,14 @@
+//{{NO_DEPENDENCIES}}
+// Microsoft Visual C++ generated include file.
+// Used by MouseHighlighter.rc
+
+//////////////////////////////
+// Non-localizable
+
+#define FILE_DESCRIPTION "PowerToys MouseHighlighter"
+#define INTERNAL_NAME "MouseHighlighter"
+#define ORIGINAL_FILENAME "MouseHighlighter.dll"
+#define IDS_KEYBOARDMANAGER_ICON 1001
+
+// Non-localizable
+//////////////////////////////

src/modules/MouseUtils/MouseHighlighter/trace.cpp

@@ -0,0 +1,40 @@
+#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() noexcept
+{
+    TraceLoggingRegister(g_hProvider);
+}
+
+void Trace::UnregisterProvider() noexcept
+{
+    TraceLoggingUnregister(g_hProvider);
+}
+
+// Log if the user has MouseHighlighter enabled or disabled
+void Trace::EnableMouseHighlighter(const bool enabled) noexcept
+{
+    TraceLoggingWrite(
+        g_hProvider,
+        "MouseHighlighter_EnableMouseHighlighter",
+        ProjectTelemetryPrivacyDataTag(ProjectTelemetryTag_ProductAndServicePerformance),
+        TraceLoggingKeyword(PROJECT_KEYWORD_MEASURE),
+        TraceLoggingBoolean(enabled, "Enabled"));
+}
+
+// Log that the user activated the module by starting a highlighting session
+void Trace::StartHighlightingSession() noexcept
+{
+    TraceLoggingWrite(
+        g_hProvider,
+        "MouseHighlighter_StartHighlightingSession",
+        ProjectTelemetryPrivacyDataTag(ProjectTelemetryTag_ProductAndServicePerformance),
+        TraceLoggingKeyword(PROJECT_KEYWORD_MEASURE));
+}

src/modules/MouseUtils/MouseHighlighter/trace.h

@@ -0,0 +1,14 @@
+#pragma once
+
+class Trace
+{
+public:
+    static void RegisterProvider() noexcept;
+    static void UnregisterProvider() noexcept;
+
+    // Log if the user has MouseHighlighter enabled or disabled
+    static void EnableMouseHighlighter(const bool enabled) noexcept;
+
+    // Log that the user activated the module by starting a highlighting session
+    static void StartHighlightingSession() noexcept;
+};