[FancyZones] Move FancyZones out of the runner process (#11818)

* rename dll -> FancyZonesModuleInterface (#11488)

* [FancyZones] Rename "fancyzones/tests" -> "fancyzones/FancyZonesTests" (#11492)

* [FancyZones] Rename "fancyzones/lib" -> "fancyzones/FancyZonesLib" (#11489)

* [FancyZones] New FancyZones project. (#11544)

* [FancyZones] Allow single instance of "PowerToys.FancyZones.exe" (#11558)

* [FancyZones] Updated bug reports (#11571)

* [FancyZones] Updated installer (#11572)

* [FancyZones] Update string resources (#11596)

* [FancyZones] Terminate FancyZones with runner (#11696)

* [FancyZones] Drop support for the module interface API to save settings (#11661)

* Settings telemetry for FancyZones (#11766)

* commented out test

* enable dpi awareness for the process

src/modules/fancyzones/FancyZonesLib/CallTracer.cpp

@@ -0,0 +1,53 @@
+#include "pch.h"
+#include "CallTracer.h"
+#include <thread>
+
+namespace
+{
+    // Non-localizable
+    const std::string entering = " Enter";
+    const std::string exiting = " Exit";
+
+    std::mutex indentLevelMutex;
+    std::map<std::thread::id, int> indentLevel;
+
+    std::string GetIndentation()
+    {
+        std::unique_lock lock(indentLevelMutex);
+        int level = indentLevel[std::this_thread::get_id()];
+
+        if (level <= 0)
+        {
+            return {};
+        }
+        else
+        {
+            return std::string(2 * min(level, 64) - 1, ' ') + " - ";
+        }
+    }
+
+    void Indent()
+    {
+        std::unique_lock lock(indentLevelMutex);
+        indentLevel[std::this_thread::get_id()]++;
+    }
+
+    void Unindent()
+    {
+        std::unique_lock lock(indentLevelMutex);
+        indentLevel[std::this_thread::get_id()]--;
+    }
+}
+
+CallTracer::CallTracer(const char* functionName) :
+    functionName(functionName)
+{
+    Logger::trace((GetIndentation() + functionName + entering).c_str());
+    Indent();
+}
+
+CallTracer::~CallTracer()
+{
+    Unindent();
+    Logger::trace((GetIndentation() + functionName + exiting).c_str());
+}

src/modules/fancyzones/FancyZonesLib/CallTracer.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include "common/logger/logger.h"
+
+#define _TRACER_ CallTracer callTracer(__FUNCTION__)
+
+class CallTracer
+{
+    std::string functionName;
+public:
+    CallTracer(const char* functionName);
+    ~CallTracer();
+};

src/modules/fancyzones/FancyZonesLib/FancyZones.h

@@ -0,0 +1,113 @@
+#pragma once
+
+#include <common/hooks/WinHookEvent.h>
+#include "Settings.h"
+
+#include <functional>
+
+interface IZoneWindow;
+interface IFancyZonesSettings;
+interface IZoneSet;
+
+struct WinHookEvent;
+
+interface __declspec(uuid("{50D3F0F5-736E-4186-BDF4-3D6BEE150C3A}")) IFancyZones : public IUnknown
+{
+    /**
+     * Start and initialize FancyZones.
+     */
+    IFACEMETHOD_(void, Run)
+    () = 0;
+    /**
+     * Stop FancyZones and do the clean up.
+     */
+    IFACEMETHOD_(void, Destroy)
+    () = 0;
+};
+
+/**
+ * Core FancyZones functionality.
+ */
+interface __declspec(uuid("{2CB37E8F-87E6-4AEC-B4B2-E0FDC873343F}")) IFancyZonesCallback : public IUnknown
+{
+    /**
+     * Inform FancyZones that user has switched between virtual desktops.
+     */
+    IFACEMETHOD_(void, VirtualDesktopChanged)
+    () = 0;
+    /**
+     * Callback from WinEventHook to FancyZones
+     *
+     * @param   data  Handle of window being moved or resized.
+     */
+    IFACEMETHOD_(void, HandleWinHookEvent)
+    (const WinHookEvent* data) = 0;
+    /**
+     * Process keyboard event.
+     *
+     * @param   info Information about low level keyboard event.
+     * @returns Boolean indicating if this event should be passed on further to other applications
+     *          in event chain, or should it be suppressed.
+     */
+    IFACEMETHOD_(bool, OnKeyDown)
+    (PKBDLLHOOKSTRUCT info) = 0;
+    /**
+     * Toggle FancyZones editor application.
+     */
+    IFACEMETHOD_(void, ToggleEditor)
+    () = 0;
+    /**
+     * Callback triggered when user changes FancyZones settings.
+     */
+    IFACEMETHOD_(void, SettingsChanged)
+    () = 0;
+};
+
+/**
+ * Helper functions used by each ZoneWindow (representing work area).
+ */
+interface __declspec(uuid("{5C8D99D6-34B2-4F4A-A8E5-7483F6869775}")) IZoneWindowHost : public IUnknown
+{
+    /**
+     * Assign window to appropriate zone inside new zone layout.
+     */
+    IFACEMETHOD_(void, MoveWindowsOnActiveZoneSetChange)
+    () = 0;
+    /**
+     * @returns Basic zone color.
+     */
+    IFACEMETHOD_(COLORREF, GetZoneColor)
+    () = 0;
+    /**
+     * @returns Zone border color.
+     */
+    IFACEMETHOD_(COLORREF, GetZoneBorderColor)
+    () = 0;
+    /**
+     * @returns Color used to highlight zone while giving zone layout hints.
+     */
+    IFACEMETHOD_(COLORREF, GetZoneHighlightColor)
+    () = 0;
+    /**
+     * @returns Integer in range [0, 100] indicating opacity of highlighted zone (while giving zone layout hints).
+     */
+    IFACEMETHOD_(int, GetZoneHighlightOpacity)
+    () = 0;
+    /**
+     * @returns Boolean indicating if dragged window should be transparent.
+     */
+    IFACEMETHOD_(bool, isMakeDraggedWindowTransparentActive)
+    () = 0;
+    /**
+     * @returns Boolean indicating if move/size operation is currently active.
+     */
+    IFACEMETHOD_(bool, InMoveSize)
+    () = 0;
+    /**
+     * @returns Enumeration value indicating the algorithm used to choose one of multiple overlapped zones to highlight.
+     */
+    IFACEMETHOD_(Settings::OverlappingZonesAlgorithm, GetOverlappingZonesAlgorithm)
+    () = 0;
+};
+
+winrt::com_ptr<IFancyZones> MakeFancyZones(HINSTANCE hinstance, const winrt::com_ptr<IFancyZonesSettings>& settings, std::function<void()> disableCallback) noexcept;

src/modules/fancyzones/FancyZonesLib/FancyZonesData.cpp

@@ -0,0 +1,676 @@
+#include "pch.h"
+#include "FancyZonesData.h"
+#include "FancyZonesDataTypes.h"
+#include "JsonHelpers.h"
+#include "ZoneSet.h"
+#include "Settings.h"
+#include "CallTracer.h"
+
+#include <common/utils/json.h>
+#include <FancyZonesLib/util.h>
+
+#include <shlwapi.h>
+#include <filesystem>
+#include <fstream>
+#include <optional>
+#include <regex>
+#include <sstream>
+#include <unordered_set>
+#include <common/utils/process_path.h>
+#include <common/logger/logger.h>
+
+// Non-localizable strings
+namespace NonLocalizable
+{
+    const wchar_t NullStr[] = L"null";
+
+    const wchar_t FancyZonesSettingsFile[] = L"settings.json";
+    const wchar_t FancyZonesDataFile[] = L"zones-settings.json";
+    const wchar_t FancyZonesAppZoneHistoryFile[] = L"app-zone-history.json";
+    const wchar_t FancyZonesEditorParametersFile[] = L"editor-parameters.json";
+    const wchar_t DefaultGuid[] = L"{00000000-0000-0000-0000-000000000000}";
+    const wchar_t RegistryPath[] = L"Software\\SuperFancyZones";
+}
+
+namespace
+{
+    std::wstring ExtractVirtualDesktopId(const std::wstring& deviceId)
+    {
+        // Format: <device-id>_<resolution>_<virtual-desktop-id>
+        return deviceId.substr(deviceId.rfind('_') + 1);
+    }
+
+    const std::wstring& GetTempDirPath()
+    {
+        static std::wstring tmpDirPath;
+        static std::once_flag flag;
+
+        std::call_once(flag, []() {
+            wchar_t buffer[MAX_PATH];
+
+            auto charsWritten = GetTempPath(MAX_PATH, buffer);
+            if (charsWritten > MAX_PATH || (charsWritten == 0))
+            {
+                abort();
+            }
+
+            tmpDirPath = std::wstring{ buffer };
+        });
+
+        return tmpDirPath;
+    }
+
+    bool DeleteRegistryKey(HKEY hKeyRoot, LPTSTR lpSubKey)
+    {
+        // First, see if we can delete the key without having to recurse.
+        if (ERROR_SUCCESS == RegDeleteKey(hKeyRoot, lpSubKey))
+        {
+            return true;
+        }
+
+        HKEY hKey;
+        if (ERROR_SUCCESS != RegOpenKeyEx(hKeyRoot, lpSubKey, 0, KEY_READ, &hKey))
+        {
+            return false;
+        }
+
+        // Check for an ending slash and add one if it is missing.
+        LPTSTR lpEnd = lpSubKey + lstrlen(lpSubKey);
+
+        if (*(lpEnd - 1) != TEXT('\\'))
+        {
+            *lpEnd = TEXT('\\');
+            lpEnd++;
+            *lpEnd = TEXT('\0');
+        }
+
+        // Enumerate the keys
+
+        DWORD dwSize = MAX_PATH;
+        TCHAR szName[MAX_PATH];
+        FILETIME ftWrite;
+        auto result = RegEnumKeyEx(hKey, 0, szName, &dwSize, NULL, NULL, NULL, &ftWrite);
+
+        if (result == ERROR_SUCCESS)
+        {
+            do
+            {
+                *lpEnd = TEXT('\0');
+                StringCchCat(lpSubKey, MAX_PATH * 2, szName);
+
+                if (!DeleteRegistryKey(hKeyRoot, lpSubKey))
+                {
+                    break;
+                }
+
+                dwSize = MAX_PATH;
+                result = RegEnumKeyEx(hKey, 0, szName, &dwSize, NULL, NULL, NULL, &ftWrite);
+            } while (result == ERROR_SUCCESS);
+        }
+
+        lpEnd--;
+        *lpEnd = TEXT('\0');
+
+        RegCloseKey(hKey);
+
+        // Try again to delete the root key.
+        if (ERROR_SUCCESS == RegDeleteKey(hKeyRoot, lpSubKey))
+        {
+            return true;
+        }
+
+        return false;
+    }
+
+    bool DeleteFancyZonesRegistryData()
+    {
+        wchar_t key[256];
+        StringCchPrintf(key, ARRAYSIZE(key), L"%s", NonLocalizable::RegistryPath);
+
+        HKEY hKey;
+        if (ERROR_FILE_NOT_FOUND == RegOpenKeyEx(HKEY_CURRENT_USER, key, 0, KEY_READ, &hKey))
+        {
+            return true;
+        }
+        else
+        {
+            return DeleteRegistryKey(HKEY_CURRENT_USER, key);
+        }
+    }
+}
+
+FancyZonesData& FancyZonesDataInstance()
+{
+    static FancyZonesData instance;
+    return instance;
+}
+
+FancyZonesData::FancyZonesData()
+{
+    std::wstring saveFolderPath = PTSettingsHelper::get_module_save_folder_location(NonLocalizable::FancyZonesStr);
+
+    settingsFileName = saveFolderPath + L"\\" + std::wstring(NonLocalizable::FancyZonesSettingsFile);
+    zonesSettingsFileName = saveFolderPath + L"\\" + std::wstring(NonLocalizable::FancyZonesDataFile);
+    appZoneHistoryFileName = saveFolderPath + L"\\" + std::wstring(NonLocalizable::FancyZonesAppZoneHistoryFile);
+    editorParametersFileName = saveFolderPath + L"\\" + std::wstring(NonLocalizable::FancyZonesEditorParametersFile);
+}
+
+const JSONHelpers::TDeviceInfoMap& FancyZonesData::GetDeviceInfoMap() const
+{
+    std::scoped_lock lock{ dataLock };
+    return deviceInfoMap;
+}
+
+const JSONHelpers::TCustomZoneSetsMap& FancyZonesData::GetCustomZoneSetsMap() const
+{
+    std::scoped_lock lock{ dataLock };
+    return customZoneSetsMap;
+}
+
+const std::unordered_map<std::wstring, std::vector<FancyZonesDataTypes::AppZoneHistoryData>>& FancyZonesData::GetAppZoneHistoryMap() const
+{
+    std::scoped_lock lock{ dataLock };
+    return appZoneHistoryMap;
+}
+
+std::optional<FancyZonesDataTypes::DeviceInfoData> FancyZonesData::FindDeviceInfo(const std::wstring& zoneWindowId) const
+{
+    std::scoped_lock lock{ dataLock };
+    auto it = deviceInfoMap.find(zoneWindowId);
+    return it != end(deviceInfoMap) ? std::optional{ it->second } : std::nullopt;
+}
+
+std::optional<FancyZonesDataTypes::CustomZoneSetData> FancyZonesData::FindCustomZoneSet(const std::wstring& guid) const
+{
+    std::scoped_lock lock{ dataLock };
+    auto it = customZoneSetsMap.find(guid);
+    return it != end(customZoneSetsMap) ? std::optional{ it->second } : std::nullopt;
+}
+
+bool FancyZonesData::AddDevice(const std::wstring& deviceId)
+{
+    _TRACER_;
+    using namespace FancyZonesDataTypes;
+
+    std::scoped_lock lock{ dataLock };
+    if (!deviceInfoMap.contains(deviceId))
+    {
+        // Creates default entry in map when ZoneWindow is created
+        GUID guid;
+        auto result{ CoCreateGuid(&guid) };
+        wil::unique_cotaskmem_string guidString;
+        if (result == S_OK && SUCCEEDED(StringFromCLSID(guid, &guidString)))
+        {
+            const ZoneSetData zoneSetData{ guidString.get(), ZoneSetLayoutType::PriorityGrid };
+            DeviceInfoData defaultDeviceInfoData{ zoneSetData, DefaultValues::ShowSpacing, DefaultValues::Spacing, DefaultValues::ZoneCount, DefaultValues::SensitivityRadius };
+            deviceInfoMap[deviceId] = std::move(defaultDeviceInfoData);
+        }
+        else
+        {
+            deviceInfoMap[deviceId] = DeviceInfoData{ ZoneSetData{ NonLocalizable::NullStr, ZoneSetLayoutType::Blank } };
+        }
+
+        return true;
+    }
+
+    return false;
+}
+
+void FancyZonesData::CloneDeviceInfo(const std::wstring& source, const std::wstring& destination)
+{
+    if (source == destination)
+    {
+        return;
+    }
+    std::scoped_lock lock{ dataLock };
+
+    // The source virtual desktop is deleted, simply ignore it.
+    if (!deviceInfoMap.contains(source))
+    {
+        return;
+    }
+
+    deviceInfoMap[destination] = deviceInfoMap[source];
+}
+
+void FancyZonesData::UpdatePrimaryDesktopData(const std::wstring& desktopId)
+{
+    _TRACER_;
+    // Explorer persists current virtual desktop identifier to registry on a per session basis,
+    // but only after first virtual desktop switch happens. If the user hasn't switched virtual
+    // desktops in this session value in registry will be empty and we will use default GUID in
+    // that case (00000000-0000-0000-0000-000000000000).
+    // This method will go through all our persisted data with default GUID and update it with
+    // valid one.
+    auto replaceDesktopId = [&desktopId](const std::wstring& deviceId) {
+        return deviceId.substr(0, deviceId.rfind('_') + 1) + desktopId;
+    };
+
+    std::scoped_lock lock{ dataLock };
+    bool dirtyFlag = false;
+
+    for (auto& [path, perDesktopData] : appZoneHistoryMap)
+    {
+        for (auto& data : perDesktopData)
+        {
+            if (ExtractVirtualDesktopId(data.deviceId) == NonLocalizable::DefaultGuid)
+            {
+                data.deviceId = replaceDesktopId(data.deviceId);
+                dirtyFlag = true;
+            }
+        }
+    }
+    
+    std::vector<std::wstring> toReplace{};
+    
+    for (const auto& [id, data] : deviceInfoMap)
+    {
+        if (ExtractVirtualDesktopId(id) == NonLocalizable::DefaultGuid)
+        {
+            toReplace.push_back(id);
+            dirtyFlag = true;
+        }
+    }
+    
+    for (const auto& id : toReplace)
+    {
+        auto mapEntry = deviceInfoMap.extract(id);
+        mapEntry.key() = replaceDesktopId(id);
+        deviceInfoMap.insert(std::move(mapEntry));
+    }
+    
+    // TODO: when updating the primary desktop GUID, the app zone history also needs to be updated 
+    if (dirtyFlag)
+    {
+        SaveZoneSettings();
+    }
+}
+
+void FancyZonesData::RemoveDeletedDesktops(const std::vector<std::wstring>& activeDesktops)
+{
+    std::unordered_set<std::wstring> active(std::begin(activeDesktops), std::end(activeDesktops));
+    std::scoped_lock lock{ dataLock };
+    bool dirtyFlag = false;
+
+    for (auto it = std::begin(deviceInfoMap); it != std::end(deviceInfoMap);)
+    {
+        std::wstring desktopId = ExtractVirtualDesktopId(it->first);
+        if (desktopId != NonLocalizable::DefaultGuid)
+        {
+            auto foundId = active.find(desktopId);
+            if (foundId == std::end(active))
+            {
+                RemoveDesktopAppZoneHistory(desktopId);
+                it = deviceInfoMap.erase(it);
+                dirtyFlag = true;
+                continue;
+            }
+        }
+        ++it;
+    }
+
+    if (dirtyFlag)
+    {
+        SaveAppZoneHistoryAndZoneSettings();
+    }
+}
+
+bool FancyZonesData::IsAnotherWindowOfApplicationInstanceZoned(HWND window, const std::wstring_view& deviceId) const
+{
+    std::scoped_lock lock{ dataLock };
+    auto processPath = get_process_path(window);
+    if (!processPath.empty())
+    {
+        auto history = appZoneHistoryMap.find(processPath);
+        if (history != std::end(appZoneHistoryMap))
+        {
+            auto& perDesktopData = history->second;
+            for (auto& data : perDesktopData)
+            {
+                if (data.deviceId == deviceId)
+                {
+                    DWORD processId = 0;
+                    GetWindowThreadProcessId(window, &processId);
+
+                    auto processIdIt = data.processIdToHandleMap.find(processId);
+
+                    if (processIdIt == std::end(data.processIdToHandleMap))
+                    {
+                        return false;
+                    }
+                    else if (processIdIt->second != window && IsWindow(processIdIt->second))
+                    {
+                        return true;
+                    }
+                }
+            }
+        }
+    }
+
+    return false;
+}
+
+void FancyZonesData::UpdateProcessIdToHandleMap(HWND window, const std::wstring_view& deviceId)
+{
+    std::scoped_lock lock{ dataLock };
+    auto processPath = get_process_path(window);
+    if (!processPath.empty())
+    {
+        auto history = appZoneHistoryMap.find(processPath);
+        if (history != std::end(appZoneHistoryMap))
+        {
+            auto& perDesktopData = history->second;
+            for (auto& data : perDesktopData)
+            {
+                if (data.deviceId == deviceId)
+                {
+                    DWORD processId = 0;
+                    GetWindowThreadProcessId(window, &processId);
+                    data.processIdToHandleMap[processId] = window;
+                    break;
+                }
+            }
+        }
+    }
+}
+
+std::vector<size_t> FancyZonesData::GetAppLastZoneIndexSet(HWND window, const std::wstring_view& deviceId, const std::wstring_view& zoneSetId) const
+{
+    std::scoped_lock lock{ dataLock };
+    auto processPath = get_process_path(window);
+    if (!processPath.empty())
+    {
+        auto history = appZoneHistoryMap.find(processPath);
+        if (history != std::end(appZoneHistoryMap))
+        {
+            const auto& perDesktopData = history->second;
+            for (const auto& data : perDesktopData)
+            {
+                if (data.zoneSetUuid == zoneSetId && data.deviceId == deviceId)
+                {
+                    return data.zoneIndexSet;
+                }
+            }
+        }
+    }
+
+    return {};
+}
+
+bool FancyZonesData::RemoveAppLastZone(HWND window, const std::wstring_view& deviceId, const std::wstring_view& zoneSetId)
+{
+    _TRACER_;
+    std::scoped_lock lock{ dataLock };
+    auto processPath = get_process_path(window);
+    if (!processPath.empty())
+    {
+        auto history = appZoneHistoryMap.find(processPath);
+        if (history != std::end(appZoneHistoryMap))
+        {
+            auto& perDesktopData = history->second;
+            for (auto data = std::begin(perDesktopData); data != std::end(perDesktopData);)
+            {
+                if (data->deviceId == deviceId && data->zoneSetUuid == zoneSetId)
+                {
+                    if (!IsAnotherWindowOfApplicationInstanceZoned(window, deviceId))
+                    {
+                        DWORD processId = 0;
+                        GetWindowThreadProcessId(window, &processId);
+
+                        data->processIdToHandleMap.erase(processId);
+                    }
+
+                    // if there is another instance of same application placed in the same zone don't erase history
+                    size_t windowZoneStamp = reinterpret_cast<size_t>(::GetProp(window, ZonedWindowProperties::PropertyMultipleZoneID));
+                    for (auto placedWindow : data->processIdToHandleMap)
+                    {
+                        size_t placedWindowZoneStamp = reinterpret_cast<size_t>(::GetProp(placedWindow.second, ZonedWindowProperties::PropertyMultipleZoneID));
+                        if (IsWindow(placedWindow.second) && (windowZoneStamp == placedWindowZoneStamp))
+                        {
+                            return false;
+                        }
+                    }
+
+                    data = perDesktopData.erase(data);
+                    if (perDesktopData.empty())
+                    {
+                        appZoneHistoryMap.erase(processPath);
+                    }
+                    SaveAppZoneHistory();
+                    return true;
+                }
+                else
+                {
+                    ++data;
+                }
+            }
+        }
+    }
+
+    return false;
+}
+
+bool FancyZonesData::SetAppLastZones(HWND window, const std::wstring& deviceId, const std::wstring& zoneSetId, const std::vector<size_t>& zoneIndexSet)
+{
+    _TRACER_;
+    std::scoped_lock lock{ dataLock };
+
+    if (IsAnotherWindowOfApplicationInstanceZoned(window, deviceId))
+    {
+        return false;
+    }
+
+    auto processPath = get_process_path(window);
+    if (processPath.empty())
+    {
+        return false;
+    }
+
+    DWORD processId = 0;
+    GetWindowThreadProcessId(window, &processId);
+
+    auto history = appZoneHistoryMap.find(processPath);
+    if (history != std::end(appZoneHistoryMap))
+    {
+        auto& perDesktopData = history->second;
+        for (auto& data : perDesktopData)
+        {
+            if (data.deviceId == deviceId)
+            {
+                // application already has history on this work area, update it with new window position
+                data.processIdToHandleMap[processId] = window;
+                data.zoneSetUuid = zoneSetId;
+                data.zoneIndexSet = zoneIndexSet;
+                SaveAppZoneHistory();
+                return true;
+            }
+        }
+    }
+
+    std::unordered_map<DWORD, HWND> processIdToHandleMap{};
+    processIdToHandleMap[processId] = window;
+    FancyZonesDataTypes::AppZoneHistoryData data{ .processIdToHandleMap = processIdToHandleMap,
+                                                  .zoneSetUuid = zoneSetId,
+                                                  .deviceId = deviceId,
+                                                  .zoneIndexSet = zoneIndexSet };
+
+    if (appZoneHistoryMap.contains(processPath))
+    {
+        // application already has history but on other desktop, add with new desktop info
+        appZoneHistoryMap[processPath].push_back(data);
+    }
+    else
+    {
+        // new application, create entry in app zone history map
+        appZoneHistoryMap[processPath] = std::vector<FancyZonesDataTypes::AppZoneHistoryData>{ data };
+    }
+
+    SaveAppZoneHistory();
+    return true;
+}
+
+void FancyZonesData::SetActiveZoneSet(const std::wstring& deviceId, const FancyZonesDataTypes::ZoneSetData& data)
+{
+    std::scoped_lock lock{ dataLock };
+
+    auto deviceIt = deviceInfoMap.find(deviceId);
+    if (deviceIt == deviceInfoMap.end())
+    {
+        return;
+    }
+
+    deviceIt->second.activeZoneSet = data;
+
+    // If the zone set is custom, we need to copy its properties to the device
+    auto zonesetIt = customZoneSetsMap.find(data.uuid);
+    if (zonesetIt != customZoneSetsMap.end())
+    {
+        if (zonesetIt->second.type == FancyZonesDataTypes::CustomLayoutType::Grid)
+        {
+            auto layoutInfo = std::get<FancyZonesDataTypes::GridLayoutInfo>(zonesetIt->second.info);
+            deviceIt->second.sensitivityRadius = layoutInfo.sensitivityRadius();
+            deviceIt->second.showSpacing = layoutInfo.showSpacing();
+            deviceIt->second.spacing = layoutInfo.spacing();
+            deviceIt->second.zoneCount = layoutInfo.zoneCount();
+        }
+        else if (zonesetIt->second.type == FancyZonesDataTypes::CustomLayoutType::Canvas)
+        {
+            auto layoutInfo = std::get<FancyZonesDataTypes::CanvasLayoutInfo>(zonesetIt->second.info);
+            deviceIt->second.sensitivityRadius = layoutInfo.sensitivityRadius;
+            deviceIt->second.zoneCount = (int)layoutInfo.zones.size();
+        }
+    }
+}
+
+json::JsonObject FancyZonesData::GetPersistFancyZonesJSON()
+{
+    return JSONHelpers::GetPersistFancyZonesJSON(zonesSettingsFileName, appZoneHistoryFileName);
+}
+
+void FancyZonesData::LoadFancyZonesData()
+{
+    if (!std::filesystem::exists(zonesSettingsFileName))
+    {
+        SaveAppZoneHistoryAndZoneSettings();
+    }
+    else
+    {
+        json::JsonObject fancyZonesDataJSON = GetPersistFancyZonesJSON();
+
+        appZoneHistoryMap = JSONHelpers::ParseAppZoneHistory(fancyZonesDataJSON);
+        deviceInfoMap = JSONHelpers::ParseDeviceInfos(fancyZonesDataJSON);
+        customZoneSetsMap = JSONHelpers::ParseCustomZoneSets(fancyZonesDataJSON);
+        quickKeysMap = JSONHelpers::ParseQuickKeys(fancyZonesDataJSON);
+    }
+}
+
+void FancyZonesData::SaveAppZoneHistoryAndZoneSettings() const
+{
+    SaveZoneSettings();
+    SaveAppZoneHistory();
+}
+
+void FancyZonesData::SaveZoneSettings() const
+{
+    _TRACER_;
+    std::scoped_lock lock{ dataLock };
+    JSONHelpers::SaveZoneSettings(zonesSettingsFileName, deviceInfoMap, customZoneSetsMap, quickKeysMap);
+}
+
+void FancyZonesData::SaveAppZoneHistory() const
+{
+    _TRACER_;
+    std::scoped_lock lock{ dataLock };
+    JSONHelpers::SaveAppZoneHistory(appZoneHistoryFileName, appZoneHistoryMap);
+}
+
+void FancyZonesData::SaveFancyZonesEditorParameters(bool spanZonesAcrossMonitors, const std::wstring& virtualDesktopId, const HMONITOR& targetMonitor) const
+{
+    JSONHelpers::EditorArgs argsJson; /* json arguments */
+    argsJson.processId = GetCurrentProcessId(); /* Process id */
+    argsJson.spanZonesAcrossMonitors = spanZonesAcrossMonitors; /* Span zones */
+
+    if (spanZonesAcrossMonitors)
+    {
+        auto monitorRect = FancyZonesUtils::GetAllMonitorsCombinedRect<&MONITORINFOEX::rcWork>();
+        std::wstring monitorId = FancyZonesUtils::GenerateUniqueIdAllMonitorsArea(virtualDesktopId);
+
+        JSONHelpers::MonitorInfo monitorJson;
+        monitorJson.id = monitorId;
+        monitorJson.top = monitorRect.top;
+        monitorJson.left = monitorRect.left;
+        monitorJson.isSelected = true;
+        monitorJson.dpi = 0; // unused
+
+        argsJson.monitors.emplace_back(std::move(monitorJson)); /* add monitor data */
+    }
+    else
+    {
+        std::vector<std::pair<HMONITOR, MONITORINFOEX>> allMonitors;
+        allMonitors = FancyZonesUtils::GetAllMonitorInfo<&MONITORINFOEX::rcWork>();
+
+        // device id map for correct device ids
+        std::unordered_map<std::wstring, DWORD> displayDeviceIdxMap;
+
+        for (auto& monitorData : allMonitors)
+        {
+            HMONITOR monitor = monitorData.first;
+            auto monitorInfo = monitorData.second;
+
+            JSONHelpers::MonitorInfo monitorJson;
+
+            std::wstring deviceId = FancyZonesUtils::GetDisplayDeviceId(monitorInfo.szDevice, displayDeviceIdxMap);
+            std::wstring monitorId = FancyZonesUtils::GenerateUniqueId(monitor, deviceId, virtualDesktopId);
+
+            if (monitor == targetMonitor)
+            {
+                monitorJson.isSelected = true; /* Is monitor selected for the main editor window opening */
+            }
+
+            monitorJson.id = monitorId; /* Monitor id */
+
+            UINT dpiX = 0;
+            UINT dpiY = 0;
+            if (GetDpiForMonitor(monitor, MDT_EFFECTIVE_DPI, &dpiX, &dpiY) == S_OK)
+            {
+                monitorJson.dpi = dpiX; /* DPI */
+            }
+
+            monitorJson.top = monitorInfo.rcMonitor.top; /* Top coordinate */
+            monitorJson.left = monitorInfo.rcMonitor.left; /* Left coordinate */
+
+            argsJson.monitors.emplace_back(std::move(monitorJson)); /* add monitor data */
+        }
+    }
+    
+
+    json::to_file(editorParametersFileName, JSONHelpers::EditorArgs::ToJson(argsJson));
+}
+
+void FancyZonesData::RemoveDesktopAppZoneHistory(const std::wstring& desktopId)
+{
+    for (auto it = std::begin(appZoneHistoryMap); it != std::end(appZoneHistoryMap);)
+    {
+        auto& perDesktopData = it->second;
+        for (auto desktopIt = std::begin(perDesktopData); desktopIt != std::end(perDesktopData);)
+        {
+            if (ExtractVirtualDesktopId(desktopIt->deviceId) == desktopId)
+            {
+                desktopIt = perDesktopData.erase(desktopIt);
+            }
+            else
+            {
+                ++desktopIt;
+            }
+        }
+
+        if (perDesktopData.empty())
+        {
+            it = appZoneHistoryMap.erase(it);
+        }
+        else
+        {
+            ++it;
+        }
+    }
+}

src/modules/fancyzones/FancyZonesLib/FancyZonesData.h

@@ -0,0 +1,160 @@
+#pragma once
+
+#include "JsonHelpers.h"
+
+#include <common/SettingsAPI/settings_helpers.h>
+#include <common/utils/json.h>
+#include <mutex>
+
+#include <string>
+#include <unordered_map>
+#include <optional>
+#include <vector>
+#include <winnt.h>
+#include <FancyZonesLib/JsonHelpers.h>
+
+// Non-localizable strings
+namespace NonLocalizable
+{
+    const wchar_t FancyZonesStr[] = L"FancyZones";
+}
+
+namespace FancyZonesDataTypes
+{
+    struct ZoneSetData;
+    struct DeviceIdData;
+    struct DeviceInfoData;
+    struct CustomZoneSetData;
+    struct AppZoneHistoryData;
+}
+
+#if defined(UNIT_TESTS)
+namespace FancyZonesUnitTests
+{
+    class FancyZonesDataUnitTests;
+    class FancyZonesIFancyZonesCallbackUnitTests;
+    class ZoneSetCalculateZonesUnitTests;
+    class ZoneWindowUnitTests;
+    class ZoneWindowCreationUnitTests;
+}
+#endif
+
+class FancyZonesData
+{
+public:
+    FancyZonesData();
+
+    std::optional<FancyZonesDataTypes::DeviceInfoData> FindDeviceInfo(const std::wstring& zoneWindowId) const;
+
+    std::optional<FancyZonesDataTypes::CustomZoneSetData> FindCustomZoneSet(const std::wstring& guid) const;
+
+    const JSONHelpers::TDeviceInfoMap& GetDeviceInfoMap() const;
+
+    const JSONHelpers::TCustomZoneSetsMap& GetCustomZoneSetsMap() const;
+
+    const std::unordered_map<std::wstring, std::vector<FancyZonesDataTypes::AppZoneHistoryData>>& GetAppZoneHistoryMap() const;
+
+    inline const JSONHelpers::TLayoutQuickKeysMap& GetLayoutQuickKeys() const
+    {
+        std::scoped_lock lock{ dataLock };
+        return quickKeysMap;
+    }
+
+    inline const std::wstring& GetZonesSettingsFileName() const 
+    {
+        return zonesSettingsFileName;
+    }
+
+    inline const std::wstring& GetSettingsFileName() const
+    {
+        return settingsFileName;
+    }
+
+    bool AddDevice(const std::wstring& deviceId);
+    void CloneDeviceInfo(const std::wstring& source, const std::wstring& destination);
+    void UpdatePrimaryDesktopData(const std::wstring& desktopId);
+    void RemoveDeletedDesktops(const std::vector<std::wstring>& activeDesktops);
+
+    bool IsAnotherWindowOfApplicationInstanceZoned(HWND window, const std::wstring_view& deviceId) const;
+    void UpdateProcessIdToHandleMap(HWND window, const std::wstring_view& deviceId);
+    std::vector<size_t> GetAppLastZoneIndexSet(HWND window, const std::wstring_view& deviceId, const std::wstring_view& zoneSetId) const;
+    bool RemoveAppLastZone(HWND window, const std::wstring_view& deviceId, const std::wstring_view& zoneSetId);
+    bool SetAppLastZones(HWND window, const std::wstring& deviceId, const std::wstring& zoneSetId, const std::vector<size_t>& zoneIndexSet);
+
+    void SetActiveZoneSet(const std::wstring& deviceId, const FancyZonesDataTypes::ZoneSetData& zoneSet);
+
+    json::JsonObject GetPersistFancyZonesJSON();
+
+    void LoadFancyZonesData();
+    void SaveAppZoneHistoryAndZoneSettings() const;
+    void SaveZoneSettings() const;
+    void SaveAppZoneHistory() const;
+
+    void SaveFancyZonesEditorParameters(bool spanZonesAcrossMonitors, const std::wstring& virtualDesktopId, const HMONITOR& targetMonitor) const;
+
+private:
+#if defined(UNIT_TESTS)
+    friend class FancyZonesUnitTests::FancyZonesDataUnitTests;
+    friend class FancyZonesUnitTests::FancyZonesIFancyZonesCallbackUnitTests;
+    friend class FancyZonesUnitTests::ZoneWindowUnitTests;
+    friend class FancyZonesUnitTests::ZoneWindowCreationUnitTests;
+    friend class FancyZonesUnitTests::ZoneSetCalculateZonesUnitTests;
+
+    inline void SetDeviceInfo(const std::wstring& deviceId, FancyZonesDataTypes::DeviceInfoData data)
+    {
+        deviceInfoMap[deviceId] = data;
+    }
+
+    inline void SetCustomZonesets(const std::wstring& uuid, FancyZonesDataTypes::CustomZoneSetData data)
+    {
+        customZoneSetsMap[uuid] = data;
+    }
+
+    inline bool ParseDeviceInfos(const json::JsonObject& fancyZonesDataJSON)
+    {
+        deviceInfoMap = JSONHelpers::ParseDeviceInfos(fancyZonesDataJSON);
+        return !deviceInfoMap.empty();
+    }
+
+    inline void clear_data()
+    {
+        appZoneHistoryMap.clear();
+        deviceInfoMap.clear();
+        customZoneSetsMap.clear();
+    }
+
+    inline void SetSettingsModulePath(std::wstring_view moduleName)
+    {
+        std::wstring result = PTSettingsHelper::get_module_save_folder_location(moduleName);
+        zonesSettingsFileName = result + L"\\" + std::wstring(L"zones-settings.json");
+        appZoneHistoryFileName = result + L"\\" + std::wstring(L"app-zone-history.json");
+    }
+#endif
+    void RemoveDesktopAppZoneHistory(const std::wstring& desktopId);
+
+    // Maps app path to app's zone history data
+    std::unordered_map<std::wstring, std::vector<FancyZonesDataTypes::AppZoneHistoryData>> appZoneHistoryMap{};
+    // Maps device unique ID to device data
+    JSONHelpers::TDeviceInfoMap deviceInfoMap{};
+    // Maps custom zoneset UUID to it's data
+    JSONHelpers::TCustomZoneSetsMap customZoneSetsMap{};
+    // Maps zoneset UUID with quick access keys
+    JSONHelpers::TLayoutQuickKeysMap quickKeysMap{};
+
+    std::wstring settingsFileName;
+    std::wstring zonesSettingsFileName;
+    std::wstring appZoneHistoryFileName;
+    std::wstring editorParametersFileName;
+
+    mutable std::recursive_mutex dataLock;
+};
+
+FancyZonesData& FancyZonesDataInstance();
+
+namespace DefaultValues
+{
+    const int ZoneCount = 3;
+    const bool ShowSpacing = true;
+    const int Spacing = 16;
+    const int SensitivityRadius = 20;
+}

src/modules/fancyzones/FancyZonesLib/FancyZonesDataTypes.cpp

@@ -0,0 +1,129 @@
+#include "pch.h"
+#include "util.h"
+
+#include "FancyZonesDataTypes.h"
+
+// Non-Localizable strings
+namespace NonLocalizable
+{
+    const wchar_t BlankStr[] = L"blank";
+    const wchar_t ColumnsStr[] = L"columns";
+    const wchar_t CustomStr[] = L"custom";
+    const wchar_t FocusStr[] = L"focus";
+    const wchar_t GridStr[] = L"grid";
+    const wchar_t PriorityGridStr[] = L"priority-grid";
+    const wchar_t RowsStr[] = L"rows";
+    const wchar_t TypeToStringErrorStr[] = L"TypeToString_ERROR";
+}
+
+namespace
+{
+    // From Settings.cs
+    constexpr int c_focusModelId = 0xFFFF;
+    constexpr int c_rowsModelId = 0xFFFE;
+    constexpr int c_columnsModelId = 0xFFFD;
+    constexpr int c_gridModelId = 0xFFFC;
+    constexpr int c_priorityGridModelId = 0xFFFB;
+    constexpr int c_blankCustomModelId = 0xFFFA;
+}
+
+namespace FancyZonesDataTypes
+{
+    std::wstring TypeToString(ZoneSetLayoutType type)
+    {
+        switch (type)
+        {
+        case ZoneSetLayoutType::Blank:
+            return NonLocalizable::BlankStr;
+        case ZoneSetLayoutType::Focus:
+            return NonLocalizable::FocusStr;
+        case ZoneSetLayoutType::Columns:
+            return NonLocalizable::ColumnsStr;
+        case ZoneSetLayoutType::Rows:
+            return NonLocalizable::RowsStr;
+        case ZoneSetLayoutType::Grid:
+            return NonLocalizable::GridStr;
+        case ZoneSetLayoutType::PriorityGrid:
+            return NonLocalizable::PriorityGridStr;
+        case ZoneSetLayoutType::Custom:
+            return NonLocalizable::CustomStr;
+        default:
+            return NonLocalizable::TypeToStringErrorStr;
+        }
+    }
+
+    ZoneSetLayoutType TypeFromString(const std::wstring& typeStr)
+    {
+        if (typeStr == NonLocalizable::FocusStr)
+        {
+            return ZoneSetLayoutType::Focus;
+        }
+        else if (typeStr == NonLocalizable::ColumnsStr)
+        {
+            return ZoneSetLayoutType::Columns;
+        }
+        else if (typeStr == NonLocalizable::RowsStr)
+        {
+            return ZoneSetLayoutType::Rows;
+        }
+        else if (typeStr == NonLocalizable::GridStr)
+        {
+            return ZoneSetLayoutType::Grid;
+        }
+        else if (typeStr == NonLocalizable::PriorityGridStr)
+        {
+            return ZoneSetLayoutType::PriorityGrid;
+        }
+        else if (typeStr == NonLocalizable::CustomStr)
+        {
+            return ZoneSetLayoutType::Custom;
+        }
+        else
+        {
+            return ZoneSetLayoutType::Blank;
+        }
+    }
+
+    GridLayoutInfo::GridLayoutInfo(const Minimal& info) :
+        m_rows(info.rows),
+        m_columns(info.columns)
+    {
+        m_rowsPercents.resize(m_rows, 0);
+        m_columnsPercents.resize(m_columns, 0);
+        m_cellChildMap.resize(m_rows, {});
+        for (auto& cellRow : m_cellChildMap)
+        {
+            cellRow.resize(m_columns, 0);
+        }
+    }
+
+    GridLayoutInfo::GridLayoutInfo(const Full& info) :
+        m_rows(info.rows),
+        m_columns(info.columns),
+        m_rowsPercents(info.rowsPercents),
+        m_columnsPercents(info.columnsPercents),
+        m_cellChildMap(info.cellChildMap)
+    {
+        m_rowsPercents.resize(m_rows, 0);
+        m_columnsPercents.resize(m_columns, 0);
+        m_cellChildMap.resize(m_rows, {});
+        for (auto& cellRow : m_cellChildMap)
+        {
+            cellRow.resize(m_columns, 0);
+        }
+    }
+
+    int GridLayoutInfo::zoneCount() const
+    {
+        int high = 0;
+        for (const auto& row : m_cellChildMap)
+        {
+            for (int val : row)
+            {
+                high = max(high, val);
+            }
+        }
+
+        return high + 1;
+    }
+}

src/modules/fancyzones/FancyZonesLib/FancyZonesDataTypes.h

@@ -0,0 +1,140 @@
+#pragma once
+
+#include <common/utils/json.h>
+
+#include <string>
+#include <vector>
+#include <optional>
+#include <variant>
+#include <unordered_map>
+
+#include <windef.h>
+
+namespace FancyZonesDataTypes
+{
+    enum class ZoneSetLayoutType : int
+    {
+        Blank = -1,
+        Focus,
+        Columns,
+        Rows,
+        Grid,
+        PriorityGrid,
+        Custom
+    };
+
+    std::wstring TypeToString(ZoneSetLayoutType type);
+    ZoneSetLayoutType TypeFromString(const std::wstring& typeStr);
+
+    enum class CustomLayoutType : int
+    {
+        Grid = 0,
+        Canvas
+    };
+
+    struct CanvasLayoutInfo
+    {
+        int lastWorkAreaWidth;
+        int lastWorkAreaHeight;
+
+        struct Rect
+        {
+            int x;
+            int y;
+            int width;
+            int height;
+        };
+        std::vector<CanvasLayoutInfo::Rect> zones;
+        int sensitivityRadius;
+    };
+
+    struct GridLayoutInfo
+    {
+        struct Minimal
+        {
+            int rows;
+            int columns;
+        };
+
+        struct Full
+        {
+            int rows;
+            int columns;
+            const std::vector<int>& rowsPercents;
+            const std::vector<int>& columnsPercents;
+            const std::vector<std::vector<int>>& cellChildMap;
+            bool showSpacing;
+            int spacing;
+            int sensitivityRadius;
+        };
+
+        GridLayoutInfo(const Minimal& info);
+        GridLayoutInfo(const Full& info);
+        ~GridLayoutInfo() = default;
+
+        inline std::vector<int>& rowsPercents() { return m_rowsPercents; };
+        inline std::vector<int>& columnsPercents() { return m_columnsPercents; };
+        inline std::vector<std::vector<int>>& cellChildMap() { return m_cellChildMap; };
+
+        inline int rows() const { return m_rows; }
+        inline int columns() const { return m_columns; }
+        inline const std::vector<int>& rowsPercents() const { return m_rowsPercents; };
+        inline const std::vector<int>& columnsPercents() const { return m_columnsPercents; };
+        inline const std::vector<std::vector<int>>& cellChildMap() const { return m_cellChildMap; };
+
+        inline bool showSpacing() const { return m_showSpacing; }
+        inline int spacing() const { return m_spacing; }
+        inline int sensitivityRadius() const { return m_sensitivityRadius; }
+
+        int zoneCount() const;
+
+        int m_rows;
+        int m_columns;
+        std::vector<int> m_rowsPercents;
+        std::vector<int> m_columnsPercents;
+        std::vector<std::vector<int>> m_cellChildMap;
+        bool m_showSpacing;
+        int m_spacing;
+        int m_sensitivityRadius;
+    };
+
+    struct CustomZoneSetData
+    {
+        std::wstring name;
+        CustomLayoutType type;
+        std::variant<CanvasLayoutInfo, GridLayoutInfo> info;
+    };
+
+    struct ZoneSetData
+    {
+        std::wstring uuid;
+        ZoneSetLayoutType type;
+    };
+
+    struct AppZoneHistoryData
+    {
+        std::unordered_map<DWORD, HWND> processIdToHandleMap; // Maps process id(DWORD) of application to zoned window handle(HWND)
+
+        std::wstring zoneSetUuid;
+        std::wstring deviceId;
+        std::vector<size_t> zoneIndexSet;
+    };
+
+    struct DeviceIdData
+    {
+        std::wstring deviceName;
+        int width;
+        int height;
+        GUID virtualDesktopId;
+        std::wstring monitorId;
+    };
+
+    struct DeviceInfoData
+    {
+        ZoneSetData activeZoneSet;
+        bool showSpacing;
+        int spacing;
+        int zoneCount;
+        int sensitivityRadius;
+    };
+}

src/modules/fancyzones/FancyZonesLib/FancyZonesLib.vcxproj

@@ -0,0 +1,117 @@
+<?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.200729.8\build\native\Microsoft.Windows.CppWinRT.props" Condition="Exists('..\..\..\..\packages\Microsoft.Windows.CppWinRT.2.0.200729.8\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 fancyzones.base.rc fancyzones.rc" />
+  </Target>
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>16.0</VCProjectVersion>
+    <ProjectGuid>{F9C68EDF-AC74-4B77-9AF1-005D9C9F6A99}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>FancyZonesLib</RootNamespace>
+    <ProjectName>FancyZonesLib</ProjectName>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+  </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>
+    <OutDir>$(SolutionDir)$(Platform)\$(Configuration)\modules\FancyZones\</OutDir>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <PreprocessorDefinitions>_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>..\;..\..\..\common\inc;..\..\..\common\Telemetry;..\..\;..\..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="CallTracer.h" />
+    <ClInclude Include="FancyZones.h" />
+    <ClInclude Include="FancyZonesDataTypes.h" />
+    <ClInclude Include="FancyZonesWinHookEventIDs.h" />
+    <ClInclude Include="FileWatcher.h" />
+    <ClInclude Include="GenericKeyHook.h" />
+    <ClInclude Include="FancyZonesData.h" />
+    <ClInclude Include="JsonHelpers.h" />
+    <ClInclude Include="KeyState.h" />
+    <ClInclude Include="MonitorWorkAreaHandler.h" />
+    <ClInclude Include="pch.h" />
+    <ClInclude Include="Generated Files/resource.h" />
+    <None Include="resource.base.h" />
+    <ClInclude Include="SecondaryMouseButtonsHook.h" />
+    <ClInclude Include="Settings.h" />
+    <ClInclude Include="trace.h" />
+    <ClInclude Include="util.h" />
+    <ClInclude Include="VirtualDesktopUtils.h" />
+    <ClInclude Include="WindowMoveHandler.h" />
+    <ClInclude Include="Zone.h" />
+    <ClInclude Include="ZoneSet.h" />
+    <ClInclude Include="ZoneWindow.h" />
+    <ClInclude Include="ZoneWindowDrawing.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="CallTracer.cpp" />
+    <ClCompile Include="FancyZones.cpp" />
+    <ClCompile Include="FancyZonesDataTypes.cpp" />
+    <ClCompile Include="FancyZonesWinHookEventIDs.cpp" />
+    <ClCompile Include="FancyZonesData.cpp" />
+    <ClCompile Include="FileWatcher.cpp" />
+    <ClCompile Include="JsonHelpers.cpp" />
+    <ClCompile Include="MonitorWorkAreaHandler.cpp" />
+    <ClCompile Include="OnThreadExecutor.cpp" />
+    <ClCompile Include="pch.cpp">
+      <PrecompiledHeader Condition="'$(CIBuild)'!='true'">Create</PrecompiledHeader>
+    </ClCompile>
+    <ClCompile Include="SecondaryMouseButtonsHook.cpp" />
+    <ClCompile Include="Settings.cpp" />
+    <ClCompile Include="trace.cpp" />
+    <ClCompile Include="util.cpp" />
+    <ClCompile Include="VirtualDesktopUtils.cpp" />
+    <ClCompile Include="WindowMoveHandler.cpp" />
+    <ClCompile Include="Zone.cpp" />
+    <ClCompile Include="ZoneSet.cpp" />
+    <ClCompile Include="ZoneWindow.cpp" />
+    <ClCompile Include="ZoneWindowDrawing.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="fancyzones.base.rc" />
+    <ProjectReference Include="..\..\..\common\Display\Display.vcxproj">
+      <Project>{caba8dfb-823b-4bf2-93ac-3f31984150d9}</Project>
+    </ProjectReference>
+    <ProjectReference Include="..\..\..\common\notifications\notifications.vcxproj">
+      <Project>{1d5be09d-78c0-4fd7-af00-ae7c1af7c525}</Project>
+    </ProjectReference>
+    <ResourceCompile Include="Generated Files/fancyzones.rc" />
+    <None Include="packages.config" />
+    <None Include="Resources.resx" />
+    <ProjectReference Include="..\..\..\common\logger\logger.vcxproj">
+      <Project>{d9b8fc84-322a-4f9f-bbb9-20915c47ddfd}</Project>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <Import Project="..\..\..\..\deps\spdlog.props" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="..\..\..\..\packages\Microsoft.Windows.ImplementationLibrary.1.0.200902.2\build\native\Microsoft.Windows.ImplementationLibrary.targets" Condition="Exists('..\..\..\..\packages\Microsoft.Windows.ImplementationLibrary.1.0.200902.2\build\native\Microsoft.Windows.ImplementationLibrary.targets')" />
+    <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.ImplementationLibrary.1.0.200902.2\build\native\Microsoft.Windows.ImplementationLibrary.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\..\packages\Microsoft.Windows.ImplementationLibrary.1.0.200902.2\build\native\Microsoft.Windows.ImplementationLibrary.targets'))" />
+    <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/fancyzones/FancyZonesLib/FancyZonesLib.vcxproj.filters

@@ -0,0 +1,167 @@
+<?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;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;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>{093625ff-2415-4c2c-842c-0ee7fcb1d203}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="pch.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Zone.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="ZoneSet.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="ZoneWindow.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="FancyZones.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Settings.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="util.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="trace.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="VirtualDesktopUtils.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="WindowMoveHandler.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="FancyZonesWinHookEventIDs.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="SecondaryMouseButtonsHook.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="MonitorWorkAreaHandler.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="GenericKeyHook.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="FancyZonesData.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="JsonHelpers.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="FancyZonesDataTypes.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Generated Files/resource.h">
+      <Filter>Generated Files</Filter>
+    </ClInclude>
+    <ClInclude Include="KeyState.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="ZoneWindowDrawing.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="FileWatcher.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="CallTracer.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="pch.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Zone.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="ZoneSet.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="ZoneWindow.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="FancyZones.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Settings.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="trace.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="util.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="VirtualDesktopUtils.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="WindowMoveHandler.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="FancyZonesWinHookEventIDs.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="SecondaryMouseButtonsHook.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="MonitorWorkAreaHandler.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="FancyZonesData.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="JsonHelpers.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="FancyZonesDataTypes.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="ZoneWindowDrawing.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="OnThreadExecutor.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="FileWatcher.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="CallTracer.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config" />
+    <None Include="resource.base.h">
+      <Filter>Header Files</Filter>
+    </None>
+    <None Include="fancyzones.base.rc">
+      <Filter>Resource Files</Filter>
+    </None>
+    <None Include="Resources.resx">
+      <Filter>Resource Files</Filter>
+    </None>
+  </ItemGroup>
+  <ItemGroup>
+    <ResourceCompile Include="Generated Files/fancyzones.rc">
+      <Filter>Generated Files</Filter>
+    </ResourceCompile>
+  </ItemGroup>
+</Project>

src/modules/fancyzones/FancyZonesLib/FancyZonesWinHookEventIDs.cpp

@@ -0,0 +1,24 @@
+#include "pch.h"
+
+#include <mutex>
+
+#include "FancyZonesWinHookEventIDs.h"
+
+UINT WM_PRIV_MOVESIZESTART;
+UINT WM_PRIV_MOVESIZEEND;
+UINT WM_PRIV_LOCATIONCHANGE;
+UINT WM_PRIV_NAMECHANGE;
+UINT WM_PRIV_WINDOWCREATED;
+
+std::once_flag init_flag;
+
+void InitializeWinhookEventIds()
+{
+    std::call_once(init_flag, [&] {
+        WM_PRIV_MOVESIZESTART = RegisterWindowMessage(L"{f48def23-df42-4c0f-a13d-3eb4a9e204d4}");
+        WM_PRIV_MOVESIZEEND = RegisterWindowMessage(L"{805d643c-804d-4728-b533-907d760ebaf0}");
+        WM_PRIV_LOCATIONCHANGE = RegisterWindowMessage(L"{d56c5ee7-58e5-481c-8c4f-8844cf4d0347}");
+        WM_PRIV_NAMECHANGE = RegisterWindowMessage(L"{b7b30c61-bfa0-4d95-bcde-fc4f2cbf6d76}");
+        WM_PRIV_WINDOWCREATED = RegisterWindowMessage(L"{bdb10669-75da-480a-9ec4-eeebf09a02d7}");
+    });
+}

src/modules/fancyzones/FancyZonesLib/FancyZonesWinHookEventIDs.h

@@ -0,0 +1,9 @@
+#pragma once
+
+extern UINT WM_PRIV_MOVESIZESTART;
+extern UINT WM_PRIV_MOVESIZEEND;
+extern UINT WM_PRIV_LOCATIONCHANGE;
+extern UINT WM_PRIV_NAMECHANGE;
+extern UINT WM_PRIV_WINDOWCREATED;
+
+void InitializeWinhookEventIds();

src/modules/fancyzones/FancyZonesLib/FileWatcher.cpp

@@ -0,0 +1,68 @@
+#include "pch.h"
+#include "FileWatcher.h"
+
+std::optional<FILETIME> FileWatcher::MyFileTime()
+{
+    HANDLE hFile = CreateFileW(m_path.c_str(), FILE_READ_ATTRIBUTES, FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr, OPEN_EXISTING, 0, nullptr);
+    std::optional<FILETIME> result;
+    if (hFile != INVALID_HANDLE_VALUE)
+    {
+        FILETIME lastWrite;
+        if (GetFileTime(hFile, nullptr, nullptr, &lastWrite))
+        {
+            result = lastWrite;
+        }
+
+        CloseHandle(hFile);
+    }
+
+    return result;
+}
+
+void FileWatcher::Run()
+{
+    while (1)
+    {
+        auto lastWrite = MyFileTime();
+        if (!m_lastWrite.has_value())
+        {
+            m_lastWrite = lastWrite;
+        }
+        else if (lastWrite.has_value())
+        {
+            if (m_lastWrite->dwHighDateTime != lastWrite->dwHighDateTime ||
+                m_lastWrite->dwLowDateTime != lastWrite->dwLowDateTime)
+            {
+                m_lastWrite = lastWrite;
+                m_callback();
+            }
+        }
+
+        if (WaitForSingleObject(m_abortEvent, m_refreshPeriod) == WAIT_OBJECT_0)
+        {
+            return;
+        }
+    }
+}
+
+FileWatcher::FileWatcher(const std::wstring& path, std::function<void()> callback, DWORD refreshPeriod) :
+    m_refreshPeriod(refreshPeriod),
+    m_path(path),
+    m_callback(callback)
+{
+    m_abortEvent = CreateEventW(nullptr, TRUE, FALSE, nullptr);
+    if (m_abortEvent)
+    {
+        m_thread = std::thread([this]() { Run(); });
+    }
+}
+
+FileWatcher::~FileWatcher()
+{
+    if (m_abortEvent)
+    {
+        SetEvent(m_abortEvent);
+        m_thread.join();
+        CloseHandle(m_abortEvent);
+    }
+}

src/modules/fancyzones/FancyZonesLib/FileWatcher.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "pch.h"
+
+class FileWatcher
+{
+    DWORD m_refreshPeriod;
+    std::wstring m_path;
+    std::optional<FILETIME> m_lastWrite;
+    std::function<void()> m_callback;
+    HANDLE m_abortEvent;
+    std::thread m_thread;
+    
+    std::optional<FILETIME> MyFileTime();
+    void Run();
+public:
+    FileWatcher(const std::wstring& path, std::function<void()> callback, DWORD refreshPeriod = 1000);
+    ~FileWatcher();
+};

src/modules/fancyzones/FancyZonesLib/GenericKeyHook.h

@@ -0,0 +1,60 @@
+#pragma once
+
+#include "pch.h"
+#include <functional>
+#include <common/debug_control.h>
+
+template<int... keys>
+class GenericKeyHook
+{
+public:
+
+    GenericKeyHook(std::function<void(bool)> extCallback)
+    {
+        callback = std::move(extCallback);
+    }
+
+    void enable()
+    {
+#if defined(DISABLE_LOWLEVEL_HOOKS_WHEN_DEBUGGED)
+        if (IsDebuggerPresent())
+        {
+            return;
+        }
+#endif
+        if (!hHook)
+        {
+            hHook = SetWindowsHookEx(WH_KEYBOARD_LL, GenericKeyHookProc, GetModuleHandle(NULL), 0);
+        }
+    }
+
+    void disable()
+    {
+        if (hHook)
+        {
+            UnhookWindowsHookEx(hHook);
+            hHook = NULL;
+            callback(false);
+        }
+    }
+
+private:
+    inline static HHOOK hHook = nullptr;
+    inline static std::function<void(bool)> callback;
+
+    static LRESULT CALLBACK GenericKeyHookProc(int nCode, WPARAM wParam, LPARAM lParam)
+    {
+        if (nCode == HC_ACTION)
+        {
+            if (wParam == WM_KEYDOWN || wParam == WM_KEYUP)
+            {
+                PKBDLLHOOKSTRUCT kbdHookStruct = (PKBDLLHOOKSTRUCT)lParam;
+                if (((kbdHookStruct->vkCode == keys) || ...))
+                {
+                    callback(wParam == WM_KEYDOWN);
+                }
+            }
+        }
+        return CallNextHookEx(hHook, nCode, wParam, lParam);
+    }
+};

src/modules/fancyzones/FancyZonesLib/JsonHelpers.cpp

@@ -0,0 +1,750 @@
+#include "pch.h"
+
+#include "JsonHelpers.h"
+#include "FancyZonesData.h"
+#include "FancyZonesDataTypes.h"
+#include "trace.h"
+#include "util.h"
+
+#include <common/logger/logger.h>
+
+#include <filesystem>
+#include <optional>
+#include <utility>
+#include <vector>
+
+// Non-Localizable strings
+namespace NonLocalizable
+{
+    const wchar_t ActiveZoneSetStr[] = L"active-zoneset";
+    const wchar_t AppPathStr[] = L"app-path";
+    const wchar_t AppZoneHistoryStr[] = L"app-zone-history";
+    const wchar_t CanvasStr[] = L"canvas";
+    const wchar_t CellChildMapStr[] = L"cell-child-map";
+    const wchar_t ColumnsPercentageStr[] = L"columns-percentage";
+    const wchar_t ColumnsStr[] = L"columns";
+    const wchar_t CustomZoneSetsStr[] = L"custom-zone-sets";
+    const wchar_t DeviceIdStr[] = L"device-id";
+    const wchar_t DevicesStr[] = L"devices";
+    const wchar_t EditorShowSpacingStr[] = L"editor-show-spacing";
+    const wchar_t EditorSpacingStr[] = L"editor-spacing";
+    const wchar_t EditorZoneCountStr[] = L"editor-zone-count";
+    const wchar_t EditorSensitivityRadiusStr[] = L"editor-sensitivity-radius";
+    const wchar_t GridStr[] = L"grid";
+    const wchar_t HeightStr[] = L"height";
+    const wchar_t HistoryStr[] = L"history";
+    const wchar_t InfoStr[] = L"info";
+    const wchar_t NameStr[] = L"name";
+    const wchar_t QuickAccessKey[] = L"key";
+    const wchar_t QuickAccessUuid[] = L"uuid";
+    const wchar_t QuickLayoutKeys[] = L"quick-layout-keys";
+    const wchar_t RefHeightStr[] = L"ref-height";
+    const wchar_t RefWidthStr[] = L"ref-width";
+    const wchar_t RowsPercentageStr[] = L"rows-percentage";
+    const wchar_t RowsStr[] = L"rows";
+    const wchar_t SensitivityRadius[] = L"sensitivity-radius";
+    const wchar_t ShowSpacing[] = L"show-spacing";
+    const wchar_t Spacing[] = L"spacing";
+    const wchar_t Templates[] = L"templates";
+    const wchar_t TypeStr[] = L"type";
+    const wchar_t UuidStr[] = L"uuid";
+    const wchar_t WidthStr[] = L"width";
+    const wchar_t XStr[] = L"X";
+    const wchar_t YStr[] = L"Y";
+    const wchar_t ZoneIndexSetStr[] = L"zone-index-set";
+    const wchar_t ZoneIndexStr[] = L"zone-index";
+    const wchar_t ZoneSetUuidStr[] = L"zoneset-uuid";
+    const wchar_t ZonesStr[] = L"zones";
+
+    // Editor arguments
+    const wchar_t Dpi[] = L"dpi";
+    const wchar_t MonitorId[] = L"monitor-id";
+    const wchar_t TopCoordinate[] = L"top-coordinate";
+    const wchar_t LeftCoordinate[] = L"left-coordinate";
+    const wchar_t IsSelected[] = L"is-selected";
+    const wchar_t ProcessId[] = L"process-id";
+    const wchar_t SpanZonesAcrossMonitors[] = L"span-zones-across-monitors";
+    const wchar_t Monitors[] = L"monitors";
+}
+
+namespace
+{
+    json::JsonArray NumVecToJsonArray(const std::vector<int>& vec)
+    {
+        json::JsonArray arr;
+        for (const auto& val : vec)
+        {
+            arr.Append(json::JsonValue::CreateNumberValue(val));
+        }
+
+        return arr;
+    }
+
+    std::vector<int> JsonArrayToNumVec(const json::JsonArray& arr)
+    {
+        std::vector<int> vec;
+        for (const auto& val : arr)
+        {
+            vec.emplace_back(static_cast<int>(val.GetNumber()));
+        }
+
+        return vec;
+    }
+
+    std::optional<FancyZonesDataTypes::AppZoneHistoryData> ParseSingleAppZoneHistoryItem(const json::JsonObject& json)
+    {
+        FancyZonesDataTypes::AppZoneHistoryData data;
+        if (json.HasKey(NonLocalizable::ZoneIndexSetStr))
+        {
+            data.zoneIndexSet = {};
+            for (const auto& value : json.GetNamedArray(NonLocalizable::ZoneIndexSetStr))
+            {
+                data.zoneIndexSet.push_back(static_cast<size_t>(value.GetNumber()));
+            }
+        }
+        else if (json.HasKey(NonLocalizable::ZoneIndexStr))
+        {
+            data.zoneIndexSet = { static_cast<size_t>(json.GetNamedNumber(NonLocalizable::ZoneIndexStr)) };
+        }
+
+        data.deviceId = json.GetNamedString(NonLocalizable::DeviceIdStr);
+        data.zoneSetUuid = json.GetNamedString(NonLocalizable::ZoneSetUuidStr);
+
+        if (!FancyZonesUtils::IsValidGuid(data.zoneSetUuid) || !FancyZonesUtils::IsValidDeviceId(data.deviceId))
+        {
+            return std::nullopt;
+        }
+
+        return data;
+    }
+
+    inline bool DeleteTmpFile(std::wstring_view tmpFilePath)
+    {
+        return DeleteFileW(tmpFilePath.data());
+    }
+}
+
+namespace JSONHelpers
+{
+    json::JsonObject CanvasLayoutInfoJSON::ToJson(const FancyZonesDataTypes::CanvasLayoutInfo& canvasInfo)
+    {
+        json::JsonObject infoJson{};
+        infoJson.SetNamedValue(NonLocalizable::RefWidthStr, json::value(canvasInfo.lastWorkAreaWidth));
+        infoJson.SetNamedValue(NonLocalizable::RefHeightStr, json::value(canvasInfo.lastWorkAreaHeight));
+
+        json::JsonArray zonesJson;
+
+        for (const auto& [x, y, width, height] : canvasInfo.zones)
+        {
+            json::JsonObject zoneJson;
+            zoneJson.SetNamedValue(NonLocalizable::XStr, json::value(x));
+            zoneJson.SetNamedValue(NonLocalizable::YStr, json::value(y));
+            zoneJson.SetNamedValue(NonLocalizable::WidthStr, json::value(width));
+            zoneJson.SetNamedValue(NonLocalizable::HeightStr, json::value(height));
+            zonesJson.Append(zoneJson);
+        }
+        infoJson.SetNamedValue(NonLocalizable::ZonesStr, zonesJson);
+        infoJson.SetNamedValue(NonLocalizable::SensitivityRadius, json::value(canvasInfo.sensitivityRadius));
+        return infoJson;
+    }
+
+    std::optional<FancyZonesDataTypes::CanvasLayoutInfo> CanvasLayoutInfoJSON::FromJson(const json::JsonObject& infoJson)
+    {
+        try
+        {
+            FancyZonesDataTypes::CanvasLayoutInfo info;
+            info.lastWorkAreaWidth = static_cast<int>(infoJson.GetNamedNumber(NonLocalizable::RefWidthStr));
+            info.lastWorkAreaHeight = static_cast<int>(infoJson.GetNamedNumber(NonLocalizable::RefHeightStr));
+
+            json::JsonArray zonesJson = infoJson.GetNamedArray(NonLocalizable::ZonesStr);
+            uint32_t size = zonesJson.Size();
+            info.zones.reserve(size);
+            for (uint32_t i = 0; i < size; ++i)
+            {
+                json::JsonObject zoneJson = zonesJson.GetObjectAt(i);
+                const int x = static_cast<int>(zoneJson.GetNamedNumber(NonLocalizable::XStr));
+                const int y = static_cast<int>(zoneJson.GetNamedNumber(NonLocalizable::YStr));
+                const int width = static_cast<int>(zoneJson.GetNamedNumber(NonLocalizable::WidthStr));
+                const int height = static_cast<int>(zoneJson.GetNamedNumber(NonLocalizable::HeightStr));
+                FancyZonesDataTypes::CanvasLayoutInfo::Rect zone{ x, y, width, height };
+                info.zones.push_back(zone);
+            }
+
+            info.sensitivityRadius = static_cast<int>(infoJson.GetNamedNumber(NonLocalizable::SensitivityRadius, DefaultValues::SensitivityRadius));
+            return info;
+        }
+        catch (const winrt::hresult_error&)
+        {
+            return std::nullopt;
+        }
+    }
+
+    json::JsonObject GridLayoutInfoJSON::ToJson(const FancyZonesDataTypes::GridLayoutInfo& gridInfo)
+    {
+        json::JsonObject infoJson;
+        infoJson.SetNamedValue(NonLocalizable::RowsStr, json::value(gridInfo.m_rows));
+        infoJson.SetNamedValue(NonLocalizable::ColumnsStr, json::value(gridInfo.m_columns));
+        infoJson.SetNamedValue(NonLocalizable::RowsPercentageStr, NumVecToJsonArray(gridInfo.m_rowsPercents));
+        infoJson.SetNamedValue(NonLocalizable::ColumnsPercentageStr, NumVecToJsonArray(gridInfo.m_columnsPercents));
+
+        json::JsonArray cellChildMapJson;
+        for (int i = 0; i < gridInfo.m_cellChildMap.size(); ++i)
+        {
+            cellChildMapJson.Append(NumVecToJsonArray(gridInfo.m_cellChildMap[i]));
+        }
+        infoJson.SetNamedValue(NonLocalizable::CellChildMapStr, cellChildMapJson);
+        
+        infoJson.SetNamedValue(NonLocalizable::SensitivityRadius, json::value(gridInfo.m_sensitivityRadius));
+        infoJson.SetNamedValue(NonLocalizable::ShowSpacing, json::value(gridInfo.m_showSpacing));
+        infoJson.SetNamedValue(NonLocalizable::Spacing, json::value(gridInfo.m_spacing));
+
+        return infoJson;
+    }
+
+    std::optional<FancyZonesDataTypes::GridLayoutInfo> GridLayoutInfoJSON::FromJson(const json::JsonObject& infoJson)
+    {
+        try
+        {
+            FancyZonesDataTypes::GridLayoutInfo info(FancyZonesDataTypes::GridLayoutInfo::Minimal{});
+
+            info.m_rows = static_cast<int>(infoJson.GetNamedNumber(NonLocalizable::RowsStr));
+            info.m_columns = static_cast<int>(infoJson.GetNamedNumber(NonLocalizable::ColumnsStr));
+
+            json::JsonArray rowsPercentage = infoJson.GetNamedArray(NonLocalizable::RowsPercentageStr);
+            json::JsonArray columnsPercentage = infoJson.GetNamedArray(NonLocalizable::ColumnsPercentageStr);
+            json::JsonArray cellChildMap = infoJson.GetNamedArray(NonLocalizable::CellChildMapStr);
+
+            if (rowsPercentage.Size() != info.m_rows || columnsPercentage.Size() != info.m_columns || cellChildMap.Size() != info.m_rows)
+            {
+                return std::nullopt;
+            }
+
+            info.m_rowsPercents = JsonArrayToNumVec(rowsPercentage);
+            info.m_columnsPercents = JsonArrayToNumVec(columnsPercentage);
+            for (const auto& cellsRow : cellChildMap)
+            {
+                const auto cellsArray = cellsRow.GetArray();
+                if (cellsArray.Size() != info.m_columns)
+                {
+                    return std::nullopt;
+                }
+                info.cellChildMap().push_back(JsonArrayToNumVec(cellsArray));
+            }
+
+            info.m_showSpacing = infoJson.GetNamedBoolean(NonLocalizable::ShowSpacing, DefaultValues::ShowSpacing);
+            info.m_spacing = static_cast<int>(infoJson.GetNamedNumber(NonLocalizable::Spacing, DefaultValues::Spacing));
+            info.m_sensitivityRadius = static_cast<int>(infoJson.GetNamedNumber(NonLocalizable::SensitivityRadius, DefaultValues::SensitivityRadius));
+
+            return info;
+        }
+        catch (const winrt::hresult_error&)
+        {
+            return std::nullopt;
+        }
+    }
+
+    json::JsonObject CustomZoneSetJSON::ToJson(const CustomZoneSetJSON& customZoneSet)
+    {
+        json::JsonObject result{};
+
+        result.SetNamedValue(NonLocalizable::UuidStr, json::value(customZoneSet.uuid));
+        result.SetNamedValue(NonLocalizable::NameStr, json::value(customZoneSet.data.name));
+        switch (customZoneSet.data.type)
+        {
+        case FancyZonesDataTypes::CustomLayoutType::Canvas:
+        {
+            result.SetNamedValue(NonLocalizable::TypeStr, json::value(NonLocalizable::CanvasStr));
+
+            FancyZonesDataTypes::CanvasLayoutInfo info = std::get<FancyZonesDataTypes::CanvasLayoutInfo>(customZoneSet.data.info);
+            result.SetNamedValue(NonLocalizable::InfoStr, CanvasLayoutInfoJSON::ToJson(info));
+
+            break;
+        }
+        case FancyZonesDataTypes::CustomLayoutType::Grid:
+        {
+            result.SetNamedValue(NonLocalizable::TypeStr, json::value(NonLocalizable::GridStr));
+
+            FancyZonesDataTypes::GridLayoutInfo gridInfo = std::get<FancyZonesDataTypes::GridLayoutInfo>(customZoneSet.data.info);
+            result.SetNamedValue(NonLocalizable::InfoStr, GridLayoutInfoJSON::ToJson(gridInfo));
+
+            break;
+        }
+        }
+
+        return result;
+    }
+
+    std::optional<CustomZoneSetJSON> CustomZoneSetJSON::FromJson(const json::JsonObject& customZoneSet)
+    {
+        try
+        {
+            CustomZoneSetJSON result;
+
+            result.uuid = customZoneSet.GetNamedString(NonLocalizable::UuidStr);
+            if (!FancyZonesUtils::IsValidGuid(result.uuid))
+            {
+                return std::nullopt;
+            }
+
+            result.data.name = customZoneSet.GetNamedString(NonLocalizable::NameStr);
+
+            json::JsonObject infoJson = customZoneSet.GetNamedObject(NonLocalizable::InfoStr);
+            std::wstring zoneSetType = std::wstring{ customZoneSet.GetNamedString(NonLocalizable::TypeStr) };
+            if (zoneSetType.compare(NonLocalizable::CanvasStr) == 0)
+            {
+                if (auto info = CanvasLayoutInfoJSON::FromJson(infoJson); info.has_value())
+                {
+                    result.data.type = FancyZonesDataTypes::CustomLayoutType::Canvas;
+                    result.data.info = std::move(info.value());
+                }
+                else
+                {
+                    return std::nullopt;
+                }
+            }
+            else if (zoneSetType.compare(NonLocalizable::GridStr) == 0)
+            {
+                if (auto info = GridLayoutInfoJSON::FromJson(infoJson); info.has_value())
+                {
+                    result.data.type = FancyZonesDataTypes::CustomLayoutType::Grid;
+                    result.data.info = std::move(info.value());
+                }
+                else
+                {
+                    return std::nullopt;
+                }
+            }
+            else
+            {
+                return std::nullopt;
+            }
+
+            return result;
+        }
+        catch (const winrt::hresult_error&)
+        {
+            return std::nullopt;
+        }
+    }
+
+    json::JsonObject ZoneSetDataJSON::ToJson(const FancyZonesDataTypes::ZoneSetData& zoneSet)
+    {
+        json::JsonObject result{};
+
+        result.SetNamedValue(NonLocalizable::UuidStr, json::value(zoneSet.uuid));
+        result.SetNamedValue(NonLocalizable::TypeStr, json::value(TypeToString(zoneSet.type)));
+
+        return result;
+    }
+
+    std::optional<FancyZonesDataTypes::ZoneSetData> ZoneSetDataJSON::FromJson(const json::JsonObject& zoneSet)
+    {
+        try
+        {
+            FancyZonesDataTypes::ZoneSetData zoneSetData;
+            zoneSetData.uuid = zoneSet.GetNamedString(NonLocalizable::UuidStr);
+            zoneSetData.type = FancyZonesDataTypes::TypeFromString(std::wstring{ zoneSet.GetNamedString(NonLocalizable::TypeStr) });
+
+            if (!FancyZonesUtils::IsValidGuid(zoneSetData.uuid))
+            {
+                return std::nullopt;
+            }
+
+            return zoneSetData;
+        }
+        catch (const winrt::hresult_error&)
+        {
+            return std::nullopt;
+        }
+    }
+
+    json::JsonObject AppZoneHistoryJSON::ToJson(const AppZoneHistoryJSON& appZoneHistory)
+    {
+        json::JsonObject result{};
+
+        result.SetNamedValue(NonLocalizable::AppPathStr, json::value(appZoneHistory.appPath));
+
+        json::JsonArray appHistoryArray;
+        for (const auto& data : appZoneHistory.data)
+        {
+            json::JsonObject desktopData;
+            json::JsonArray jsonIndexSet;
+            for (size_t index : data.zoneIndexSet)
+            {
+                jsonIndexSet.Append(json::value(static_cast<int>(index)));
+            }
+
+            desktopData.SetNamedValue(NonLocalizable::ZoneIndexSetStr, jsonIndexSet);
+            desktopData.SetNamedValue(NonLocalizable::DeviceIdStr, json::value(data.deviceId));
+            desktopData.SetNamedValue(NonLocalizable::ZoneSetUuidStr, json::value(data.zoneSetUuid));
+
+            appHistoryArray.Append(desktopData);
+        }
+
+        result.SetNamedValue(NonLocalizable::HistoryStr, appHistoryArray);
+
+        return result;
+    }
+
+    std::optional<AppZoneHistoryJSON> AppZoneHistoryJSON::FromJson(const json::JsonObject& zoneSet)
+    {
+        try
+        {
+            AppZoneHistoryJSON result;
+
+            result.appPath = zoneSet.GetNamedString(NonLocalizable::AppPathStr);
+            if (zoneSet.HasKey(NonLocalizable::HistoryStr))
+            {
+                auto appHistoryArray = zoneSet.GetNamedArray(NonLocalizable::HistoryStr);
+                for (uint32_t i = 0; i < appHistoryArray.Size(); ++i)
+                {
+                    json::JsonObject json = appHistoryArray.GetObjectAt(i);
+                    if (auto data = ParseSingleAppZoneHistoryItem(json); data.has_value())
+                    {
+                        result.data.push_back(std::move(data.value()));
+                    }
+                }
+            }
+            else
+            {
+                // handle previous file format, with single desktop layout information per application
+                if (auto data = ParseSingleAppZoneHistoryItem(zoneSet); data.has_value())
+                {
+                    result.data.push_back(std::move(data.value()));
+                }
+            }
+            if (result.data.empty())
+            {
+                return std::nullopt;
+            }
+
+            return result;
+        }
+        catch (const winrt::hresult_error&)
+        {
+            return std::nullopt;
+        }
+    }
+
+    json::JsonObject DeviceInfoJSON::ToJson(const DeviceInfoJSON& device)
+    {
+        json::JsonObject result{};
+
+        result.SetNamedValue(NonLocalizable::DeviceIdStr, json::value(device.deviceId));
+        result.SetNamedValue(NonLocalizable::ActiveZoneSetStr, JSONHelpers::ZoneSetDataJSON::ToJson(device.data.activeZoneSet));
+        result.SetNamedValue(NonLocalizable::EditorShowSpacingStr, json::value(device.data.showSpacing));
+        result.SetNamedValue(NonLocalizable::EditorSpacingStr, json::value(device.data.spacing));
+        result.SetNamedValue(NonLocalizable::EditorZoneCountStr, json::value(device.data.zoneCount));
+        result.SetNamedValue(NonLocalizable::EditorSensitivityRadiusStr, json::value(device.data.sensitivityRadius));
+
+        return result;
+    }
+
+    std::optional<DeviceInfoJSON> DeviceInfoJSON::FromJson(const json::JsonObject& device)
+    {
+        try
+        {
+            DeviceInfoJSON result;
+
+            result.deviceId = device.GetNamedString(NonLocalizable::DeviceIdStr);
+            if (!FancyZonesUtils::IsValidDeviceId(result.deviceId))
+            {
+                return std::nullopt;
+            }
+
+            if (auto zoneSet = JSONHelpers::ZoneSetDataJSON::FromJson(device.GetNamedObject(NonLocalizable::ActiveZoneSetStr)); zoneSet.has_value())
+            {
+                result.data.activeZoneSet = std::move(zoneSet.value());
+            }
+            else
+            {
+                return std::nullopt;
+            }
+
+            result.data.showSpacing = device.GetNamedBoolean(NonLocalizable::EditorShowSpacingStr);
+            result.data.spacing = static_cast<int>(device.GetNamedNumber(NonLocalizable::EditorSpacingStr));
+            result.data.zoneCount = static_cast<int>(device.GetNamedNumber(NonLocalizable::EditorZoneCountStr));
+            result.data.sensitivityRadius = static_cast<int>(device.GetNamedNumber(NonLocalizable::EditorSensitivityRadiusStr, DefaultValues::SensitivityRadius));
+
+            return result;
+        }
+        catch (const winrt::hresult_error&)
+        {
+            return std::nullopt;
+        }
+    }
+
+    json::JsonObject LayoutQuickKeyJSON::ToJson(const LayoutQuickKeyJSON& layoutQuickKey)
+    {
+        json::JsonObject result{};
+
+        result.SetNamedValue(NonLocalizable::QuickAccessUuid, json::value(layoutQuickKey.layoutUuid));
+        result.SetNamedValue(NonLocalizable::QuickAccessKey, json::value(layoutQuickKey.key));
+
+        return result;
+    }
+    
+    std::optional<LayoutQuickKeyJSON> LayoutQuickKeyJSON::FromJson(const json::JsonObject& layoutQuickKey)
+    {
+        try
+        {
+            LayoutQuickKeyJSON result;
+
+            result.layoutUuid = layoutQuickKey.GetNamedString(NonLocalizable::QuickAccessUuid);
+            if (!FancyZonesUtils::IsValidGuid(result.layoutUuid))
+            {
+                return std::nullopt;
+            }
+
+            result.key = static_cast<int>(layoutQuickKey.GetNamedNumber(NonLocalizable::QuickAccessKey));
+            
+            return result;
+        }
+        catch (const winrt::hresult_error&)
+        {
+            return std::nullopt;
+        }
+    }
+
+    json::JsonObject MonitorInfo::ToJson(const MonitorInfo& monitor)
+    {
+        json::JsonObject result{};
+
+        result.SetNamedValue(NonLocalizable::Dpi, json::value(monitor.dpi));
+        result.SetNamedValue(NonLocalizable::MonitorId, json::value(monitor.id));
+        result.SetNamedValue(NonLocalizable::TopCoordinate, json::value(monitor.top));
+        result.SetNamedValue(NonLocalizable::LeftCoordinate, json::value(monitor.left));
+        result.SetNamedValue(NonLocalizable::IsSelected, json::value(monitor.isSelected));
+
+        return result;
+    }
+
+    json::JsonObject EditorArgs::ToJson(const EditorArgs& args)
+    {
+        json::JsonObject result{};
+
+        result.SetNamedValue(NonLocalizable::ProcessId, json::value(args.processId));
+        result.SetNamedValue(NonLocalizable::SpanZonesAcrossMonitors, json::value(args.spanZonesAcrossMonitors));
+
+        json::JsonArray monitors;
+        for (const auto& monitor : args.monitors)
+        {
+            monitors.Append(MonitorInfo::ToJson(monitor));
+        }
+
+        result.SetNamedValue(NonLocalizable::Monitors, monitors);
+
+        return result;
+    }
+
+    json::JsonObject GetPersistFancyZonesJSON(const std::wstring& zonesSettingsFileName, const std::wstring& appZoneHistoryFileName)
+    {
+        auto result = json::from_file(zonesSettingsFileName);
+        if (result)
+        {
+            if (!result->HasKey(NonLocalizable::AppZoneHistoryStr))
+            {
+                auto appZoneHistory = json::from_file(appZoneHistoryFileName);
+                if (appZoneHistory)
+                {
+                    result->SetNamedValue(NonLocalizable::AppZoneHistoryStr, appZoneHistory->GetNamedArray(NonLocalizable::AppZoneHistoryStr));
+                }
+                else
+                {
+                    result->SetNamedValue(NonLocalizable::AppZoneHistoryStr, json::JsonArray());
+                }
+            }
+            return *result;
+        }
+        else
+        {
+            return json::JsonObject();
+        }
+    }
+
+    void SaveZoneSettings(const std::wstring& zonesSettingsFileName, const TDeviceInfoMap& deviceInfoMap, const TCustomZoneSetsMap& customZoneSetsMap, const TLayoutQuickKeysMap& quickKeysMap)
+    {
+        auto before = json::from_file(zonesSettingsFileName);
+
+        json::JsonObject root{};
+        json::JsonArray templates{};
+
+        try
+        {
+            if (before.has_value() && before->HasKey(NonLocalizable::Templates))
+            {
+                templates = before->GetNamedArray(NonLocalizable::Templates);
+            }
+        }
+        catch (const winrt::hresult_error&)
+        {
+        
+        }
+               
+        root.SetNamedValue(NonLocalizable::DevicesStr, JSONHelpers::SerializeDeviceInfos(deviceInfoMap));
+        root.SetNamedValue(NonLocalizable::CustomZoneSetsStr, JSONHelpers::SerializeCustomZoneSets(customZoneSetsMap));
+        root.SetNamedValue(NonLocalizable::Templates, templates);
+        root.SetNamedValue(NonLocalizable::QuickLayoutKeys, JSONHelpers::SerializeQuickKeys(quickKeysMap));
+        
+        if (!before.has_value() || before.value().Stringify() != root.Stringify())
+        {
+            Trace::FancyZones::DataChanged();
+            json::to_file(zonesSettingsFileName, root);
+        }
+    }
+
+    void SaveAppZoneHistory(const std::wstring& appZoneHistoryFileName, const TAppZoneHistoryMap& appZoneHistoryMap)
+    {
+        json::JsonObject root{};
+
+        root.SetNamedValue(NonLocalizable::AppZoneHistoryStr, JSONHelpers::SerializeAppZoneHistory(appZoneHistoryMap));
+
+        auto before = json::from_file(appZoneHistoryFileName);
+        if (!before.has_value() || before.value().Stringify() != root.Stringify())
+        {
+            json::to_file(appZoneHistoryFileName, root);
+        }
+    }
+
+    TAppZoneHistoryMap ParseAppZoneHistory(const json::JsonObject& fancyZonesDataJSON)
+    {
+        try
+        {
+            TAppZoneHistoryMap appZoneHistoryMap{};
+            auto appLastZones = fancyZonesDataJSON.GetNamedArray(NonLocalizable::AppZoneHistoryStr);
+
+            for (uint32_t i = 0; i < appLastZones.Size(); ++i)
+            {
+                json::JsonObject appLastZone = appLastZones.GetObjectAt(i);
+                if (auto appZoneHistory = AppZoneHistoryJSON::FromJson(appLastZone); appZoneHistory.has_value())
+                {
+                    appZoneHistoryMap[appZoneHistory->appPath] = std::move(appZoneHistory->data);
+                }
+            }
+
+            return std::move(appZoneHistoryMap);
+        }
+        catch (const winrt::hresult_error&)
+        {
+            return {};
+        }
+    }
+
+    json::JsonArray SerializeAppZoneHistory(const TAppZoneHistoryMap& appZoneHistoryMap)
+    {
+        json::JsonArray appHistoryArray;
+
+        for (const auto& [appPath, appZoneHistoryData] : appZoneHistoryMap)
+        {
+            appHistoryArray.Append(AppZoneHistoryJSON::ToJson(AppZoneHistoryJSON{ appPath, appZoneHistoryData }));
+        }
+
+        return appHistoryArray;
+    }
+
+    TDeviceInfoMap ParseDeviceInfos(const json::JsonObject& fancyZonesDataJSON)
+    {
+        try
+        {
+            TDeviceInfoMap deviceInfoMap{};
+            auto devices = fancyZonesDataJSON.GetNamedArray(NonLocalizable::DevicesStr);
+
+            for (uint32_t i = 0; i < devices.Size(); ++i)
+            {
+                if (auto device = DeviceInfoJSON::DeviceInfoJSON::FromJson(devices.GetObjectAt(i)); device.has_value())
+                {
+                    deviceInfoMap[device->deviceId] = std::move(device->data);
+                }
+            }
+
+            return std::move(deviceInfoMap);
+        }
+        catch (const winrt::hresult_error&)
+        {
+            return {};
+        }
+    }
+
+    json::JsonArray SerializeDeviceInfos(const TDeviceInfoMap& deviceInfoMap)
+    {
+        json::JsonArray DeviceInfosJSON{};
+
+        for (const auto& [deviceID, deviceData] : deviceInfoMap)
+        {
+            DeviceInfosJSON.Append(DeviceInfoJSON::DeviceInfoJSON::ToJson(DeviceInfoJSON{ deviceID, deviceData }));
+        }
+
+        return DeviceInfosJSON;
+    }
+
+    TCustomZoneSetsMap ParseCustomZoneSets(const json::JsonObject& fancyZonesDataJSON)
+    {
+        try
+        {
+            TCustomZoneSetsMap customZoneSetsMap{};
+            auto customZoneSets = fancyZonesDataJSON.GetNamedArray(NonLocalizable::CustomZoneSetsStr);
+
+            for (uint32_t i = 0; i < customZoneSets.Size(); ++i)
+            {
+                if (auto zoneSet = CustomZoneSetJSON::FromJson(customZoneSets.GetObjectAt(i)); zoneSet.has_value())
+                {
+                    customZoneSetsMap[zoneSet->uuid] = std::move(zoneSet->data);
+                }
+            }
+
+            return std::move(customZoneSetsMap);
+        }
+        catch (const winrt::hresult_error&)
+        {
+            return {};
+        }
+    }
+
+    json::JsonArray SerializeCustomZoneSets(const TCustomZoneSetsMap& customZoneSetsMap)
+    {
+        json::JsonArray customZoneSetsJSON{};
+
+        for (const auto& [zoneSetId, zoneSetData] : customZoneSetsMap)
+        {
+            customZoneSetsJSON.Append(CustomZoneSetJSON::ToJson(CustomZoneSetJSON{ zoneSetId, zoneSetData }));
+        }
+
+        return customZoneSetsJSON;
+    }
+    
+    TLayoutQuickKeysMap ParseQuickKeys(const json::JsonObject& fancyZonesDataJSON)
+    {
+        try
+        {
+            TLayoutQuickKeysMap quickKeysMap{};
+            auto quickKeys = fancyZonesDataJSON.GetNamedArray(NonLocalizable::QuickLayoutKeys);
+
+            for (uint32_t i = 0; i < quickKeys.Size(); ++i)
+            {
+                if (auto quickKey = LayoutQuickKeyJSON::FromJson(quickKeys.GetObjectAt(i)); quickKey.has_value())
+                {
+                    quickKeysMap[quickKey->layoutUuid] = std::move(quickKey->key);
+                }
+            }
+
+            return std::move(quickKeysMap);
+        }
+        catch (const winrt::hresult_error& e)
+        {
+            Logger::error(L"Parsing quick keys error: {}", e.message());
+            return {};
+        }
+    }
+
+    json::JsonArray SerializeQuickKeys(const TLayoutQuickKeysMap& quickKeysMap)
+    {
+        json::JsonArray quickKeysJSON{};
+
+        for (const auto& [uuid, key] : quickKeysMap)
+        {
+            quickKeysJSON.Append(LayoutQuickKeyJSON::ToJson(LayoutQuickKeyJSON{ uuid, key }));
+        }
+
+        return quickKeysJSON;
+    }
+}

src/modules/fancyzones/FancyZonesLib/JsonHelpers.h

@@ -0,0 +1,108 @@
+#pragma once
+
+#include "FancyZonesDataTypes.h"
+
+#include <common/utils/json.h>
+
+#include <string>
+#include <vector>
+#include <unordered_map>
+
+namespace JSONHelpers
+{
+    namespace CanvasLayoutInfoJSON
+    {
+        json::JsonObject ToJson(const FancyZonesDataTypes::CanvasLayoutInfo& canvasInfo);
+        std::optional<FancyZonesDataTypes::CanvasLayoutInfo> FromJson(const json::JsonObject& infoJson);
+    }
+
+    namespace GridLayoutInfoJSON
+    {
+        json::JsonObject ToJson(const FancyZonesDataTypes::GridLayoutInfo& gridInfo);
+        std::optional<FancyZonesDataTypes::GridLayoutInfo> FromJson(const json::JsonObject& infoJson);
+    }
+
+    struct CustomZoneSetJSON
+    {
+        std::wstring uuid;
+        FancyZonesDataTypes::CustomZoneSetData data;
+
+        static json::JsonObject ToJson(const CustomZoneSetJSON& device);
+        static std::optional<CustomZoneSetJSON> FromJson(const json::JsonObject& customZoneSet);
+    };
+
+    namespace ZoneSetDataJSON
+    {
+        json::JsonObject ToJson(const FancyZonesDataTypes::ZoneSetData& zoneSet);
+        std::optional<FancyZonesDataTypes::ZoneSetData> FromJson(const json::JsonObject& zoneSet);
+    };
+
+    struct AppZoneHistoryJSON
+    {
+        std::wstring appPath;
+        std::vector<FancyZonesDataTypes::AppZoneHistoryData> data;
+
+        static json::JsonObject ToJson(const AppZoneHistoryJSON& appZoneHistory);
+        static std::optional<AppZoneHistoryJSON> FromJson(const json::JsonObject& zoneSet);
+    };
+
+    struct DeviceInfoJSON
+    {
+        std::wstring deviceId;
+        FancyZonesDataTypes::DeviceInfoData data;
+
+        static json::JsonObject ToJson(const DeviceInfoJSON& device);
+        static std::optional<DeviceInfoJSON> FromJson(const json::JsonObject& device);
+    };
+
+    struct LayoutQuickKeyJSON
+    {
+        std::wstring layoutUuid;
+        int key;
+
+        static json::JsonObject ToJson(const LayoutQuickKeyJSON& device);
+        static std::optional<LayoutQuickKeyJSON> FromJson(const json::JsonObject& device);
+    };
+
+    using TAppZoneHistoryMap = std::unordered_map<std::wstring, std::vector<FancyZonesDataTypes::AppZoneHistoryData>>;
+    using TDeviceInfoMap = std::unordered_map<std::wstring, FancyZonesDataTypes::DeviceInfoData>;
+    using TCustomZoneSetsMap = std::unordered_map<std::wstring, FancyZonesDataTypes::CustomZoneSetData>;
+    using TLayoutQuickKeysMap = std::unordered_map<std::wstring, int>;
+
+    struct MonitorInfo
+    {
+        int dpi;
+        std::wstring id;
+        int top;
+        int left;
+        bool isSelected = false;
+
+        static json::JsonObject ToJson(const MonitorInfo& monitor);
+    };
+    
+    struct EditorArgs
+    {
+        DWORD processId;
+        bool spanZonesAcrossMonitors;
+        std::vector<MonitorInfo> monitors;
+
+        static json::JsonObject ToJson(const EditorArgs& args);
+    };
+
+    json::JsonObject GetPersistFancyZonesJSON(const std::wstring& zonesSettingsFileName, const std::wstring& appZoneHistoryFileName);
+
+    void SaveZoneSettings(const std::wstring& zonesSettingsFileName, const TDeviceInfoMap& deviceInfoMap, const TCustomZoneSetsMap& customZoneSetsMap, const TLayoutQuickKeysMap& quickKeysMap);
+    void SaveAppZoneHistory(const std::wstring& appZoneHistoryFileName, const TAppZoneHistoryMap& appZoneHistoryMap);
+
+    TAppZoneHistoryMap ParseAppZoneHistory(const json::JsonObject& fancyZonesDataJSON);
+    json::JsonArray SerializeAppZoneHistory(const TAppZoneHistoryMap& appZoneHistoryMap);
+
+    TDeviceInfoMap ParseDeviceInfos(const json::JsonObject& fancyZonesDataJSON);
+    json::JsonArray SerializeDeviceInfos(const TDeviceInfoMap& deviceInfoMap);
+
+    TCustomZoneSetsMap ParseCustomZoneSets(const json::JsonObject& fancyZonesDataJSON);
+    json::JsonArray SerializeCustomZoneSets(const TCustomZoneSetsMap& customZoneSetsMap);
+
+    TLayoutQuickKeysMap ParseQuickKeys(const json::JsonObject& fancyZonesDataJSON);
+    json::JsonArray SerializeQuickKeys(const TLayoutQuickKeysMap& quickKeysMap);
+}

src/modules/fancyzones/FancyZonesLib/KeyState.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#include "GenericKeyHook.h"
+
+template<int... keys>
+class KeyState
+{
+public:
+    KeyState(const std::function<void()>& callback) :
+        m_state(false),
+        m_hook(std::bind(&KeyState::onChangeState, this, std::placeholders::_1)),
+        m_updateCallback(callback)
+    {
+    
+    }
+
+    inline bool state() const noexcept { return m_state; }
+
+    inline void enable()
+    {
+        m_hook.enable();
+        m_state = (((GetAsyncKeyState(keys) & 0x8000) || ...));
+    }
+
+    inline void disable()
+    {
+        m_hook.disable();
+    }
+
+    inline void setState(bool state) noexcept
+    {
+        if (m_state != state)
+        {
+            m_state = state;
+            if (m_updateCallback)
+            {
+                m_updateCallback();
+            }
+        }
+    }
+
+private:
+    inline void onChangeState(bool state) noexcept
+    {
+        setState(state);
+    }
+
+private:
+    std::atomic<bool> m_state;
+    GenericKeyHook<keys...> m_hook;
+    std::function<void()> m_updateCallback;
+};

src/modules/fancyzones/FancyZonesLib/LocProject.json

@@ -0,0 +1,14 @@
+{
+    "Projects": [
+        {
+            "LanguageSet": "Azure_Languages",
+            "LocItems": [
+                {
+                    "SourceFile": "src\\modules\\fancyzones\\FancyZonesLib\\Resources.resx",
+                    "CopyOption": "LangIDOnName",
+                    "OutputPath": "src\\modules\\fancyzones\\FancyZonesLib"
+                }
+            ]
+        }
+    ]
+}

src/modules/fancyzones/FancyZonesLib/MonitorWorkAreaHandler.cpp

@@ -0,0 +1,136 @@
+#include "pch.h"
+#include "MonitorWorkAreaHandler.h"
+#include "VirtualDesktopUtils.h"
+
+winrt::com_ptr<IZoneWindow> MonitorWorkAreaHandler::GetWorkArea(const GUID& desktopId, HMONITOR monitor)
+{
+    auto desktopIt = workAreaMap.find(desktopId);
+    if (desktopIt != std::end(workAreaMap))
+    {
+        auto& perDesktopData = desktopIt->second;
+        auto monitorIt = perDesktopData.find(monitor);
+        if (monitorIt != std::end(perDesktopData))
+        {
+            return monitorIt->second;
+        }
+    }
+    return nullptr;
+}
+
+winrt::com_ptr<IZoneWindow> MonitorWorkAreaHandler::GetWorkAreaFromCursor(const GUID& desktopId)
+{
+    auto allMonitorsWorkArea = GetWorkArea(desktopId, NULL);
+    if (allMonitorsWorkArea)
+    {
+        // First, check if there's a work area spanning all monitors (signalled by the NULL monitor handle)
+        return allMonitorsWorkArea;
+    }
+    else
+    {
+        // Otherwise, look for the work area based on cursor position
+        POINT cursorPoint;
+        if (!GetCursorPos(&cursorPoint))
+        {
+            return nullptr;
+        }
+
+        return GetWorkArea(desktopId, MonitorFromPoint(cursorPoint, MONITOR_DEFAULTTONULL));
+    }
+}
+
+winrt::com_ptr<IZoneWindow> MonitorWorkAreaHandler::GetWorkArea(HWND window)
+{
+    GUID desktopId{};
+    if (VirtualDesktopUtils::GetWindowDesktopId(window, &desktopId))
+    {
+        auto allMonitorsWorkArea = GetWorkArea(desktopId, NULL);
+        if (allMonitorsWorkArea)
+        {
+            // First, check if there's a work area spanning all monitors (signalled by the NULL monitor handle)
+            return allMonitorsWorkArea;
+        }
+        else
+        {
+            // Otherwise, look for the work area based on the window's position
+            HMONITOR monitor = MonitorFromWindow(window, MONITOR_DEFAULTTONULL);
+            return GetWorkArea(desktopId, monitor);
+        }
+    }
+
+    return nullptr;
+}
+
+const std::unordered_map<HMONITOR, winrt::com_ptr<IZoneWindow>>& MonitorWorkAreaHandler::GetWorkAreasByDesktopId(const GUID& desktopId)
+{
+    if (workAreaMap.contains(desktopId))
+    {
+        return workAreaMap[desktopId];
+    }
+    static const std::unordered_map<HMONITOR, winrt::com_ptr<IZoneWindow>> empty;
+    return empty;
+}
+
+std::vector<winrt::com_ptr<IZoneWindow>> MonitorWorkAreaHandler::GetAllWorkAreas()
+{
+    std::vector<winrt::com_ptr<IZoneWindow>> workAreas{};
+    for (const auto& [desktopId, perDesktopData] : workAreaMap)
+    {
+        std::transform(std::begin(perDesktopData),
+                       std::end(perDesktopData),
+                       std::back_inserter(workAreas),
+                       [](const auto& item) { return item.second; });
+    }
+    return workAreas;
+}
+
+void MonitorWorkAreaHandler::AddWorkArea(const GUID& desktopId, HMONITOR monitor, winrt::com_ptr<IZoneWindow>& workArea)
+{
+    if (!workAreaMap.contains(desktopId))
+    {
+        workAreaMap[desktopId] = {};
+    }
+    auto& perDesktopData = workAreaMap[desktopId];
+    perDesktopData[monitor] = std::move(workArea);
+}
+
+bool MonitorWorkAreaHandler::IsNewWorkArea(const GUID& desktopId, HMONITOR monitor)
+{
+    if (workAreaMap.contains(desktopId))
+    {
+        const auto& perDesktopData = workAreaMap[desktopId];
+        if (perDesktopData.contains(monitor))
+        {
+            return false;
+        }
+    }
+    return true;
+}
+
+void MonitorWorkAreaHandler::RegisterUpdates(const std::vector<GUID>& active)
+{
+    std::unordered_set<GUID> activeVirtualDesktops(std::begin(active), std::end(active));
+    for (auto desktopIt = std::begin(workAreaMap); desktopIt != std::end(workAreaMap);)
+    {
+        auto activeIt = activeVirtualDesktops.find(desktopIt->first);
+        if (activeIt == std::end(activeVirtualDesktops))
+        {
+            // virtual desktop deleted, remove entry from the map
+            desktopIt = workAreaMap.erase(desktopIt);
+        }
+        else
+        {
+            activeVirtualDesktops.erase(desktopIt->first); // virtual desktop already in map, skip it
+            ++desktopIt;
+        }
+    }
+    // register new virtual desktops, if any
+    for (const auto& id : activeVirtualDesktops)
+    {
+        workAreaMap[id] = {};
+    }
+}
+
+void MonitorWorkAreaHandler::Clear()
+{
+    workAreaMap.clear();
+}

src/modules/fancyzones/FancyZonesLib/MonitorWorkAreaHandler.h

@@ -0,0 +1,101 @@
+#pragma once
+
+interface IZoneWindow;
+
+namespace std
+{
+    template<>
+    struct hash<GUID>
+    {
+        size_t operator()(const GUID& Value) const
+        {
+            RPC_STATUS status = RPC_S_OK;
+            return ::UuidHash(&const_cast<GUID&>(Value), &status);
+        }
+    };
+}
+
+class MonitorWorkAreaHandler
+{
+public:
+    /**
+     * Get work area based on virtual desktop id and monitor handle.
+     *
+     * @param[in]  desktopId Virtual desktop identifier.
+     * @param[in]  monitor   Monitor handle.
+     *
+     * @returns    Object representing single work area, interface to all actions available on work area
+     *             (e.g. moving windows through zone layout specified for that work area).
+     */
+    winrt::com_ptr<IZoneWindow> GetWorkArea(const GUID& desktopId, HMONITOR monitor);
+
+    /**
+     * Get work area based on virtual desktop id and the current cursor position.
+     *
+     * @param[in]  desktopId Virtual desktop identifier.
+     *
+     * @returns    Object representing single work area, interface to all actions available on work area
+     *             (e.g. moving windows through zone layout specified for that work area).
+     */
+    winrt::com_ptr<IZoneWindow> GetWorkAreaFromCursor(const GUID& desktopId);
+
+    /**
+     * Get work area on which specified window is located.
+     *
+     * @param[in]  window Window handle.
+     *
+     * @returns    Object representing single work area, interface to all actions available on work area
+     *             (e.g. moving windows through zone layout specified for that work area).
+     */
+    winrt::com_ptr<IZoneWindow> GetWorkArea(HWND window);
+
+    /**
+     * Get map of all work areas on single virtual desktop. Key in the map is monitor handle, while value
+     * represents single work area.
+     *
+     * @param[in]  desktopId Virtual desktop identifier.
+     *
+     * @returns    Map containing pairs of monitor and work area for that monitor (within same virtual desktop).
+     */
+    const std::unordered_map<HMONITOR, winrt::com_ptr<IZoneWindow>>& GetWorkAreasByDesktopId(const GUID& desktopId);
+
+    /**
+     * @returns    All registered work areas.
+     */
+    std::vector<winrt::com_ptr<IZoneWindow>> GetAllWorkAreas();
+
+    /**
+     * Register new work area.
+     *
+     * @param[in]  desktopId Virtual desktop identifier.
+     * @param[in]  monitor   Monitor handle.
+     * @param[in]  workAra   Object representing single work area.
+     */
+    void AddWorkArea(const GUID& desktopId, HMONITOR monitor, winrt::com_ptr<IZoneWindow>& workArea);
+
+    /**
+     * Check if work area is already registered.
+     *
+     * @param[in]  desktopId Virtual desktop identifier.
+     * @param[in]  monitor   Monitor handle.
+     *
+     * @returns    Boolean indicating whether work area defined by virtual desktop id and monitor is already registered.
+     */
+    bool IsNewWorkArea(const GUID& desktopId, HMONITOR monitor);
+
+    /**
+     * Register changes in current virtual desktop layout.
+     *
+     * @param[in]  active  Array of currently active virtual desktop identifiers.
+     */
+    void RegisterUpdates(const std::vector<GUID>& active);
+
+    /**
+     * Clear all persisted work area related data.
+     */
+    void Clear();
+
+private:
+    // Work area is uniquely defined by monitor and virtual desktop id.
+    std::unordered_map<GUID, std::unordered_map<HMONITOR, winrt::com_ptr<IZoneWindow>>> workAreaMap;
+};

src/modules/fancyzones/FancyZonesLib/OnThreadExecutor.cpp

@@ -0,0 +1,53 @@
+#include "pch.h"
+
+#include "on_thread_executor.h"
+#include "CallTracer.h"
+
+OnThreadExecutor::OnThreadExecutor() :
+    _shutdown_request{ false }, _worker_thread{ [this] { worker_thread(); } }
+{
+}
+
+std::future<void> OnThreadExecutor::submit(task_t task)
+{
+    auto future = task.get_future();
+    std::lock_guard lock{ _task_mutex };
+    _task_queue.emplace(std::move(task));
+    _task_cv.notify_one();
+    return future;
+}
+
+void OnThreadExecutor::cancel()
+{
+    std::lock_guard lock{ _task_mutex };
+    _task_queue = {};
+    _task_cv.notify_one();
+}
+
+
+void OnThreadExecutor::worker_thread()
+{
+    while (!_shutdown_request)
+    {
+        task_t task;
+        {
+            CallTracer callTracer(__FUNCTION__ "(loop)");
+            std::unique_lock task_lock{ _task_mutex };
+            _task_cv.wait(task_lock, [this] { return !_task_queue.empty() || _shutdown_request; });
+            if (_shutdown_request)
+            {
+                return;
+            }
+            task = std::move(_task_queue.front());
+            _task_queue.pop();
+        }
+        task();
+    }
+}
+
+OnThreadExecutor::~OnThreadExecutor()
+{
+    _shutdown_request = true;
+    _task_cv.notify_one();
+    _worker_thread.join();
+}

src/modules/fancyzones/FancyZonesLib/Resources.resx

@@ -0,0 +1,257 @@
+<?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="Setting_Description" xml:space="preserve">
+    <value>Create window layouts to help make multi-tasking easy</value>
+    <comment>this is NOT referring to the operating system.</comment>
+  </data>
+  <data name="Setting_Description_ShiftDrag" xml:space="preserve">
+    <value>Hold Shift key to activate zones while dragging</value>
+    <comment>SHIFT is referring to keyboard key.</comment>
+  </data>
+  <data name="Setting_Description_MouseSwitch" xml:space="preserve">
+    <value>Use a non-primary mouse button to toggle zone activation</value>
+  </data>
+  <data name="Setting_Description_Override_Snap_Hotkeys" xml:space="preserve">
+    <value>Override Windows Snap hotkeys (Win + Arrow) to move windows between zones</value>
+    <comment>Windows is referring to OS. Win is referring to Windows Key, "Arrow" is referring to keyboard key.</comment>
+  </data>
+  <data name="Setting_Description_Move_Window_Across_Monitors" xml:space="preserve">
+    <value>Move windows between zones across all monitors when snapping with (Win + Arrow)</value>
+    <comment>windows is referring to the display surfaces like applications, not the OS.  Win is referring to Windows Key, "Arrow" is referring to keyboard key.</comment>
+  </data>
+  <data name="Setting_Description_Move_Windows_Based_On_Position" xml:space="preserve">
+    <value>Move windows based on their position when snapping with (Win + Arrow)</value>
+    <comment>windows is referring to the display surfaces like applications, not the OS.  Win is referring to Windows Key, "Arrow" is referring to keyboard key.</comment>
+  </data>
+  <data name="Setting_Description_DisplayChange_MoveWindows" xml:space="preserve">
+    <value>Keep windows in their zones when the screen resolution changes</value>
+    <comment>windows is referring to the display surfaces like applications, not the OS.</comment>
+  </data>
+  <data name="Setting_Description_ZoneSetChange_MoveWindows" xml:space="preserve">
+    <value>During zone layout changes, windows assigned to a zone will match new size/positions</value>
+    <comment>windows is referring to the display surfaces like applications, not the OS.</comment>
+  </data>
+  <data name="Setting_Description_ZoneSetChange_FlashZones" xml:space="preserve">
+    <value>Flash zones when the active FancyZones layout changes</value>
+    <comment>Flash refers to blinking the zone so it appears/disappears.  FancyZones is the product name</comment>
+  </data>
+  <data name="Setting_Description_Show_Fancy_Zones_On_All_Monitors" xml:space="preserve">
+    <value>Show zones on all monitors while dragging a window</value>
+  </data>
+  <data name="Setting_Description_Span_Zones_Across_Monitors" xml:space="preserve">
+    <value>Allow zones to span across monitors (all monitors must have the same DPI scaling)</value>
+  </data>
+  <data name="Setting_Description_Make_Dragged_Window_Transparent" xml:space="preserve">
+    <value>Make dragged window transparent</value>
+  </data>
+  <data name="Setting_Description_ZoneColor" xml:space="preserve">
+    <value>Zone inactive color (Default #F5FCFF)</value>
+  </data>
+  <data name="Setting_Description_Zone_Border_Color" xml:space="preserve">
+    <value>Zone border color (Default #FFFFFF)</value>
+  </data>
+  <data name="Setting_Description_ZoneHighlightColor" xml:space="preserve">
+    <value>Zone highlight color (Default #008CFF)</value>
+  </data>
+  <data name="Setting_Description_Use_CursorPos_Editor_StartupScreen" xml:space="preserve">
+    <value>Follow mouse cursor instead of focus when launching editor in a multi-screen environment</value>
+  </data>
+  <data name="Setting_Description_AppLastZone_MoveWindows" xml:space="preserve">
+    <value>Move newly created windows to their last known zone</value>
+    <comment>windows is referring to the display surfaces like applications, not the OS.</comment>
+  </data>
+  <data name="Setting_Description_Open_Window_On_Active_Monitor" xml:space="preserve">
+    <value>Move newly created windows to the current active monitor [EXPERIMENTAL]</value>
+  </data>
+  <data name="Setting_Description_RestoreSize" xml:space="preserve">
+    <value>Restore the original size of windows when unsnapping</value>
+  </data>
+  <data name="Setting_Launch_Editor_Label" xml:space="preserve">
+    <value>Zone configuration</value>
+  </data>
+  <data name="Setting_Launch_Editor_Button" xml:space="preserve">
+    <value>Edit zones</value>
+  </data>
+  <data name="Setting_Launch_Editor_Description" xml:space="preserve">
+    <value>To launch the zone editor, select the Edit zones button below or press the zone editor hotkey anytime</value>
+    <comment>"Edit zones" must match value from Setting_Launch_Editor_Button value</comment>
+  </data>
+  <data name="Setting_Launch_Editor_Hotkey_Label" xml:space="preserve">
+    <value>Configure the zone editor hotkey</value>
+  </data>
+  <data name="Setting_Excluded_Apps_Description" xml:space="preserve">
+    <value>To exclude an application from snapping to zones add its name here (one per line). Excluded apps will react to the Windows Snap regardless of all other settings.</value>
+    <comment>Windows refers to the Operating system</comment>
+  </data>
+  <data name="Settings_Highlight_Opacity" xml:space="preserve">
+    <value>Zone opacity (%)</value>
+    <comment>a zone is a snapping region and can be transparent</comment>
+  </data>
+  <data name="FancyZones" xml:space="preserve">
+    <value>FancyZones</value>
+    <comment>FancyZone is a product name, keep as is.</comment>
+  </data>
+  <data name="Cant_Drag_Elevated" xml:space="preserve">
+    <value>We've detected an application running with administrator privileges. This will prevent certain interactions with these applications.</value>
+    <comment>administrator is context of user account.</comment> 
+  </data>
+  <data name="Cant_Drag_Elevated_Learn_More" xml:space="preserve">
+    <value>Learn more</value>
+  </data>
+  <data name="Cant_Drag_Elevated_Dialog_Dont_Show_Again" xml:space="preserve">
+    <value>Don't show again</value>
+  </data>
+  <data name="Keyboard_Listener_Error" xml:space="preserve">
+    <value>Failed to install keyboard listener.</value>
+  </data>
+  <data name="Window_Event_Listener_Error" xml:space="preserve">
+    <value>Failed to install Windows event listener.</value>
+    <comment>Windows refers to the Operating system</comment>
+  </data>
+  <data name="Powertoys_FancyZones" xml:space="preserve">
+    <value>PowerToys - FancyZones</value>
+    <comment>do not loc.  Both are product names</comment>
+  </data>
+  <data name="Span_Across_Zones_Warning" xml:space="preserve">
+    <value>The 'Allow zones to span across monitors' option requires all monitors to have the same DPI scaling to work properly.</value>
+  </data>
+  <data name="FancyZones_Data_Error" xml:space="preserve">
+    <value>FancyZones persisted data path not found. Please report the bug to</value>
+    <comment>"Report bug to" will have a URL after. FancyZone is a product name, keep as is.</comment>
+  </data>
+  <data name="FancyZones_Editor_Launch_Error" xml:space="preserve">
+    <value>The FancyZones editor failed to start. Please report the bug to</value>
+    <comment>"Report bug to" will have a URL after. FancyZone is a product name, keep as is.</comment>
+  </data>
+  <data name="FancyZones_Settings_Load_Error" xml:space="preserve">
+    <value>Failed to load the FancyZones settings. Default settings will be used.</value>
+    <comment>FancyZone is a product name, keep as is.</comment>
+  </data>
+  <data name="FancyZones_Settings_Save_Error" xml:space="preserve">
+    <value>Failed to save the FancyZones settings. Please retry again later, if the problem persists report the bug to</value>
+    <comment>"Report bug to" will have a URL after. FancyZone is a product name, keep as is.</comment>
+  </data>
+  <data name="Setting_Description_QuickLayoutSwitch" xml:space="preserve">
+    <value>Enable quick layout switch</value>
+  </data>
+  <data name="Setting_Description_FlashZonesOnQuickSwitch" xml:space="preserve">
+    <value>Flash zones when switching layout</value>
+  </data>
+</root>

src/modules/fancyzones/FancyZonesLib/SecondaryMouseButtonsHook.cpp

@@ -0,0 +1,54 @@
+#include "pch.h"
+#include "SecondaryMouseButtonsHook.h"
+#include <common/debug_control.h>
+
+#pragma region public
+
+HHOOK SecondaryMouseButtonsHook::hHook = {};
+std::function<void()> SecondaryMouseButtonsHook::callback = {};
+
+SecondaryMouseButtonsHook::SecondaryMouseButtonsHook(std::function<void()> extCallback)
+{
+    callback = std::move(extCallback);
+}
+
+void SecondaryMouseButtonsHook::enable()
+{
+#if defined(DISABLE_LOWLEVEL_HOOKS_WHEN_DEBUGGED)
+    if (IsDebuggerPresent())
+    {
+        return;
+    }
+#endif
+    if (!hHook)
+    {
+        hHook = SetWindowsHookEx(WH_MOUSE_LL, SecondaryMouseButtonsProc, GetModuleHandle(NULL), 0);
+    }
+}
+
+void SecondaryMouseButtonsHook::disable()
+{
+    if (hHook)
+    {
+        UnhookWindowsHookEx(hHook);
+        hHook = NULL;
+    }
+}
+
+#pragma endregion
+
+#pragma region private
+
+LRESULT CALLBACK SecondaryMouseButtonsHook::SecondaryMouseButtonsProc(int nCode, WPARAM wParam, LPARAM lParam)
+{
+    if (nCode == HC_ACTION)
+    {
+        if (wParam == WM_RBUTTONDOWN || wParam == WM_MBUTTONDOWN || wParam == WM_XBUTTONDOWN)
+        {
+            callback();
+        }
+    }
+    return CallNextHookEx(hHook, nCode, wParam, lParam);
+}
+
+#pragma endregion

src/modules/fancyzones/FancyZonesLib/SecondaryMouseButtonsHook.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <functional>
+
+class SecondaryMouseButtonsHook
+{
+public:
+    SecondaryMouseButtonsHook(std::function<void()>);
+    void enable();
+    void disable();
+
+private:
+    static HHOOK hHook;
+    static std::function<void()> callback;
+    static LRESULT CALLBACK SecondaryMouseButtonsProc(int, WPARAM, LPARAM);
+};

src/modules/fancyzones/FancyZonesLib/Settings.cpp

@@ -0,0 +1,280 @@
+#include "pch.h"
+#include <common/SettingsAPI/settings_objects.h>
+#include <common/utils/resources.h>
+
+#include "FancyZonesLib/Settings.h"
+#include "FancyZonesLib/FancyZones.h"
+#include "trace.h"
+
+// Non-Localizable strings
+namespace NonLocalizable
+{
+    // FancyZones settings descriptions are localized, but underlying toggle (spinner, color picker) names are not.
+    const wchar_t ShiftDragID[] = L"fancyzones_shiftDrag";
+    const wchar_t MouseSwitchID[] = L"fancyzones_mouseSwitch";
+    const wchar_t OverrideSnapHotKeysID[] = L"fancyzones_overrideSnapHotkeys";
+    const wchar_t MoveWindowAcrossMonitorsID[] = L"fancyzones_moveWindowAcrossMonitors";
+    const wchar_t MoveWindowsBasedOnPositionID[] = L"fancyzones_moveWindowsBasedOnPosition";
+    const wchar_t OverlappingZonesAlgorithmID[] = L"fancyzones_overlappingZonesAlgorithm";
+    const wchar_t DisplayChangeMoveWindowsID[] = L"fancyzones_displayChange_moveWindows";
+    const wchar_t ZoneSetChangeMoveWindowsID[] = L"fancyzones_zoneSetChange_moveWindows";
+    const wchar_t AppLastZoneMoveWindowsID[] = L"fancyzones_appLastZone_moveWindows";
+    const wchar_t OpenWindowOnActiveMonitorID[] = L"fancyzones_openWindowOnActiveMonitor";
+    const wchar_t RestoreSizeID[] = L"fancyzones_restoreSize";
+    const wchar_t QuickLayoutSwitch[] = L"fancyzones_quickLayoutSwitch";
+    const wchar_t FlashZonesOnQuickSwitch[] = L"fancyzones_flashZonesOnQuickSwitch";
+    const wchar_t UseCursorPosEditorStartupScreenID[] = L"use_cursorpos_editor_startupscreen";
+    const wchar_t ShowOnAllMonitorsID[] = L"fancyzones_show_on_all_monitors";
+    const wchar_t SpanZonesAcrossMonitorsID[] = L"fancyzones_span_zones_across_monitors";
+    const wchar_t MakeDraggedWindowTransparentID[] = L"fancyzones_makeDraggedWindowTransparent";
+
+    const wchar_t ZoneColorID[] = L"fancyzones_zoneColor";
+    const wchar_t ZoneBorderColorID[] = L"fancyzones_zoneBorderColor";
+    const wchar_t ZoneHighlightColorID[] = L"fancyzones_zoneHighlightColor";
+    const wchar_t EditorHotkeyID[] = L"fancyzones_editor_hotkey";
+    const wchar_t ExcludedAppsID[] = L"fancyzones_excluded_apps";
+    const wchar_t ZoneHighlightOpacityID[] = L"fancyzones_highlight_opacity";
+
+    const wchar_t ToggleEditorActionID[] = L"ToggledFZEditor";
+    const wchar_t IconKeyID[] = L"pt-fancy-zones";
+    const wchar_t OverviewURL[] = L"https://aka.ms/PowerToysOverview_FancyZones";
+    const wchar_t VideoURL[] = L"https://youtu.be/rTtGzZYAXgY";
+    const wchar_t PowerToysIssuesURL[] = L"https://aka.ms/powerToysReportBug";
+}
+
+struct FancyZonesSettings : winrt::implements<FancyZonesSettings, IFancyZonesSettings>
+{
+public:
+    FancyZonesSettings(HINSTANCE hinstance, PCWSTR name, PCWSTR key) :
+        m_hinstance(hinstance),
+        m_moduleName(name),
+        m_moduleKey(key)
+    {
+        LoadSettings(name, true);
+    }
+
+    IFACEMETHODIMP_(void)
+    SetCallback(IFancyZonesCallback* callback) { m_callback = callback; }
+    IFACEMETHODIMP_(void)
+    ResetCallback() { m_callback = nullptr; }
+    IFACEMETHODIMP_(bool)
+    GetConfig(_Out_ PWSTR buffer, _Out_ int* buffer_sizeg) noexcept;
+    IFACEMETHODIMP_(void)
+    SetConfig(PCWSTR config) noexcept;
+    IFACEMETHODIMP_(void)
+    ReloadSettings() noexcept;
+    IFACEMETHODIMP_(const Settings*)
+    GetSettings() const noexcept { return &m_settings; }
+
+private:
+    void LoadSettings(PCWSTR config, bool fromFile) noexcept;
+    void SaveSettings() noexcept;
+
+    IFancyZonesCallback* m_callback{};
+    const HINSTANCE m_hinstance;
+    std::wstring m_moduleName{};
+    std::wstring m_moduleKey{};
+
+    Settings m_settings;
+
+    struct
+    {
+        PCWSTR name;
+        bool* value;
+        int resourceId;
+    } m_configBools[16] = {
+        { NonLocalizable::ShiftDragID, &m_settings.shiftDrag, IDS_SETTING_DESCRIPTION_SHIFTDRAG },
+        { NonLocalizable::MouseSwitchID, &m_settings.mouseSwitch, IDS_SETTING_DESCRIPTION_MOUSESWITCH },
+        { NonLocalizable::OverrideSnapHotKeysID, &m_settings.overrideSnapHotkeys, IDS_SETTING_DESCRIPTION_OVERRIDE_SNAP_HOTKEYS },
+        { NonLocalizable::MoveWindowAcrossMonitorsID, &m_settings.moveWindowAcrossMonitors, IDS_SETTING_DESCRIPTION_MOVE_WINDOW_ACROSS_MONITORS },
+        { NonLocalizable::MoveWindowsBasedOnPositionID, &m_settings.moveWindowsBasedOnPosition, IDS_SETTING_DESCRIPTION_MOVE_WINDOWS_BASED_ON_POSITION },
+        { NonLocalizable::DisplayChangeMoveWindowsID, &m_settings.displayChange_moveWindows, IDS_SETTING_DESCRIPTION_DISPLAYCHANGE_MOVEWINDOWS },
+        { NonLocalizable::ZoneSetChangeMoveWindowsID, &m_settings.zoneSetChange_moveWindows, IDS_SETTING_DESCRIPTION_ZONESETCHANGE_MOVEWINDOWS },
+        { NonLocalizable::AppLastZoneMoveWindowsID, &m_settings.appLastZone_moveWindows, IDS_SETTING_DESCRIPTION_APPLASTZONE_MOVEWINDOWS },
+        { NonLocalizable::OpenWindowOnActiveMonitorID, &m_settings.openWindowOnActiveMonitor, IDS_SETTING_DESCRIPTION_OPEN_WINDOW_ON_ACTIVE_MONITOR },
+        { NonLocalizable::RestoreSizeID, &m_settings.restoreSize, IDS_SETTING_DESCRIPTION_RESTORESIZE },
+        { NonLocalizable::QuickLayoutSwitch, &m_settings.quickLayoutSwitch, IDS_SETTING_DESCRIPTION_QUICKLAYOUTSWITCH },
+        { NonLocalizable::FlashZonesOnQuickSwitch, &m_settings.flashZonesOnQuickSwitch, IDS_SETTING_DESCRIPTION_FLASHZONESONQUICKSWITCH },
+        { NonLocalizable::UseCursorPosEditorStartupScreenID, &m_settings.use_cursorpos_editor_startupscreen, IDS_SETTING_DESCRIPTION_USE_CURSORPOS_EDITOR_STARTUPSCREEN },
+        { NonLocalizable::ShowOnAllMonitorsID, &m_settings.showZonesOnAllMonitors, IDS_SETTING_DESCRIPTION_SHOW_FANCY_ZONES_ON_ALL_MONITORS },
+        { NonLocalizable::SpanZonesAcrossMonitorsID, &m_settings.spanZonesAcrossMonitors, IDS_SETTING_DESCRIPTION_SPAN_ZONES_ACROSS_MONITORS },
+        { NonLocalizable::MakeDraggedWindowTransparentID, &m_settings.makeDraggedWindowTransparent, IDS_SETTING_DESCRIPTION_MAKE_DRAGGED_WINDOW_TRANSPARENT },
+    };
+};
+
+IFACEMETHODIMP_(bool)
+FancyZonesSettings::GetConfig(_Out_ PWSTR buffer, _Out_ int* buffer_size) noexcept
+{
+    PowerToysSettings::Settings settings(m_hinstance, m_moduleName);
+
+    // Pass a string literal or a resource id to Settings::set_description().
+    settings.set_description(IDS_SETTING_DESCRIPTION);
+    settings.set_icon_key(NonLocalizable::IconKeyID);
+    settings.set_overview_link(NonLocalizable::OverviewURL);
+    settings.set_video_link(NonLocalizable::VideoURL);
+
+    // Add a custom action property. When using this settings type, the "PowertoyModuleIface::call_custom_action()"
+    // method should be overridden as well.
+    settings.add_custom_action(
+        NonLocalizable::ToggleEditorActionID, // action name.
+        IDS_SETTING_LAUNCH_EDITOR_LABEL,
+        IDS_SETTING_LAUNCH_EDITOR_BUTTON,
+        IDS_SETTING_LAUNCH_EDITOR_DESCRIPTION);
+    settings.add_hotkey(NonLocalizable::EditorHotkeyID, IDS_SETTING_LAUNCH_EDITOR_HOTKEY_LABEL, m_settings.editorHotkey);
+
+    for (auto const& setting : m_configBools)
+    {
+        settings.add_bool_toggle(setting.name, setting.resourceId, *setting.value);
+    }
+
+    settings.add_color_picker(NonLocalizable::ZoneHighlightColorID, IDS_SETTING_DESCRIPTION_ZONEHIGHLIGHTCOLOR, m_settings.zoneHighlightColor);
+    settings.add_color_picker(NonLocalizable::ZoneColorID, IDS_SETTING_DESCRIPTION_ZONECOLOR, m_settings.zoneColor);
+    settings.add_color_picker(NonLocalizable::ZoneBorderColorID, IDS_SETTING_DESCRIPTION_ZONE_BORDER_COLOR, m_settings.zoneBorderColor);
+
+    settings.add_int_spinner(NonLocalizable::ZoneHighlightOpacityID, IDS_SETTINGS_HIGHLIGHT_OPACITY, m_settings.zoneHighlightOpacity, 0, 100, 1);
+
+    settings.add_multiline_string(NonLocalizable::ExcludedAppsID, IDS_SETTING_EXCLUDED_APPS_DESCRIPTION, m_settings.excludedApps);
+
+    return settings.serialize_to_buffer(buffer, buffer_size);
+}
+
+IFACEMETHODIMP_(void)
+FancyZonesSettings::SetConfig(PCWSTR serializedPowerToysSettingsJson) noexcept
+{
+    LoadSettings(serializedPowerToysSettingsJson, false /*fromFile*/);
+    SaveSettings();
+    if (m_callback)
+    {
+        m_callback->SettingsChanged();
+    }
+}
+
+IFACEMETHODIMP_(void)
+FancyZonesSettings::ReloadSettings() noexcept
+{
+    LoadSettings(m_moduleKey.c_str(), true /*fromFile*/);
+    if (m_callback)
+    {
+        m_callback->SettingsChanged();
+    }
+}
+
+void FancyZonesSettings::LoadSettings(PCWSTR config, bool fromFile) noexcept
+{
+    try
+    {
+        PowerToysSettings::PowerToyValues values = fromFile ?
+                                                       PowerToysSettings::PowerToyValues::load_from_settings_file(m_moduleKey) :
+                                                       PowerToysSettings::PowerToyValues::from_json_string(config, m_moduleKey);
+
+        for (auto const& setting : m_configBools)
+        {
+            if (const auto val = values.get_bool_value(setting.name))
+            {
+                *setting.value = *val;
+            }
+        }
+
+        if (auto val = values.get_string_value(NonLocalizable::ZoneColorID))
+        {
+            m_settings.zoneColor = std::move(*val);
+        }
+
+        if (auto val = values.get_string_value(NonLocalizable::ZoneBorderColorID))
+        {
+            m_settings.zoneBorderColor = std::move(*val);
+        }
+
+        if (auto val = values.get_string_value(NonLocalizable::ZoneHighlightColorID))
+        {
+            m_settings.zoneHighlightColor = std::move(*val);
+        }
+
+        if (const auto val = values.get_json(NonLocalizable::EditorHotkeyID))
+        {
+            m_settings.editorHotkey = PowerToysSettings::HotkeyObject::from_json(*val);
+        }
+
+        if (auto val = values.get_string_value(NonLocalizable::ExcludedAppsID))
+        {
+            m_settings.excludedApps = std::move(*val);
+            m_settings.excludedAppsArray.clear();
+            auto excludedUppercase = m_settings.excludedApps;
+            CharUpperBuffW(excludedUppercase.data(), (DWORD)excludedUppercase.length());
+            std::wstring_view view(excludedUppercase);
+            while (view.starts_with('\n') || view.starts_with('\r'))
+            {
+                view.remove_prefix(1);
+            }
+            while (!view.empty())
+            {
+                auto pos = (std::min)(view.find_first_of(L"\r\n"), view.length());
+                m_settings.excludedAppsArray.emplace_back(view.substr(0, pos));
+                view.remove_prefix(pos);
+                while (view.starts_with('\n') || view.starts_with('\r'))
+                {
+                    view.remove_prefix(1);
+                }
+            }
+        }
+
+        if (auto val = values.get_int_value(NonLocalizable::ZoneHighlightOpacityID))
+        {
+            m_settings.zoneHighlightOpacity = *val;
+        }
+
+        if (auto val = values.get_int_value(NonLocalizable::OverlappingZonesAlgorithmID))
+        {
+            // Avoid undefined behavior
+            if (*val >= 0 || *val < (int)Settings::OverlappingZonesAlgorithm::EnumElements)
+            {
+                m_settings.overlappingZonesAlgorithm = (Settings::OverlappingZonesAlgorithm)*val;
+            }
+        }
+    }
+    catch (...)
+    {
+        // Failure to load settings does not break FancyZones functionality. Display error message and continue with default settings.
+        MessageBox(NULL,
+                   GET_RESOURCE_STRING(IDS_FANCYZONES_SETTINGS_LOAD_ERROR).c_str(),
+                   GET_RESOURCE_STRING(IDS_POWERTOYS_FANCYZONES).c_str(),
+                   MB_OK);
+    }
+}
+
+void FancyZonesSettings::SaveSettings() noexcept
+{
+    try
+    {
+        PowerToysSettings::PowerToyValues values(m_moduleName, m_moduleKey);
+
+        for (auto const& setting : m_configBools)
+        {
+            values.add_property(setting.name, *setting.value);
+        }
+
+        values.add_property(NonLocalizable::ZoneColorID, m_settings.zoneColor);
+        values.add_property(NonLocalizable::ZoneBorderColorID, m_settings.zoneBorderColor);
+        values.add_property(NonLocalizable::ZoneHighlightColorID, m_settings.zoneHighlightColor);
+        values.add_property(NonLocalizable::ZoneHighlightOpacityID, m_settings.zoneHighlightOpacity);
+        values.add_property(NonLocalizable::OverlappingZonesAlgorithmID, (int)m_settings.overlappingZonesAlgorithm);
+        values.add_property(NonLocalizable::EditorHotkeyID, m_settings.editorHotkey.get_json());
+        values.add_property(NonLocalizable::ExcludedAppsID, m_settings.excludedApps);
+
+        values.save_to_settings_file();
+    }
+    catch (...)
+    {
+        // Failure to save settings does not break FancyZones functionality. Display error message and continue with currently cached settings.
+        std::wstring errorMessage = GET_RESOURCE_STRING(IDS_FANCYZONES_SETTINGS_LOAD_ERROR) + L" " + NonLocalizable::PowerToysIssuesURL;
+        MessageBox(NULL,
+                   errorMessage.c_str(),
+                   GET_RESOURCE_STRING(IDS_POWERTOYS_FANCYZONES).c_str(),
+                   MB_OK);
+    }
+}
+
+winrt::com_ptr<IFancyZonesSettings> MakeFancyZonesSettings(HINSTANCE hinstance, PCWSTR name, PCWSTR key) noexcept
+{
+    return winrt::make_self<FancyZonesSettings>(hinstance, name, key);
+}

src/modules/fancyzones/FancyZonesLib/Settings.h

@@ -0,0 +1,65 @@
+#pragma once
+
+#include <common/SettingsAPI/settings_objects.h>
+
+// Zoned window properties are not localized.
+namespace ZonedWindowProperties
+{
+    const wchar_t PropertyMultipleZoneID[]  = L"FancyZones_zones";
+    const wchar_t PropertyRestoreSizeID[]   = L"FancyZones_RestoreSize";
+    const wchar_t PropertyRestoreOriginID[] = L"FancyZones_RestoreOrigin";
+
+    const wchar_t MultiMonitorDeviceID[]    = L"FancyZones#MultiMonitorDevice";
+}
+
+// in reality, this file needs to be kept in sync currently with src/settings-ui/Microsoft.PowerToys.Settings.UI.Library/FZConfigProperties.cs
+struct Settings
+{
+    enum struct OverlappingZonesAlgorithm : int
+    {
+        Smallest = 0,
+        Largest = 1,
+        Positional = 2,
+        ClosestCenter = 3,
+        EnumElements = 4, // number of elements in the enum, not counting this
+    };
+
+    // The values specified here are the defaults.
+    bool shiftDrag = true;
+    bool mouseSwitch = false;
+    bool displayChange_moveWindows = false;
+    bool zoneSetChange_flashZones = false;
+    bool zoneSetChange_moveWindows = false;
+    bool overrideSnapHotkeys = false;
+    bool moveWindowAcrossMonitors = false;
+    bool moveWindowsBasedOnPosition = false;
+    bool appLastZone_moveWindows = false;
+    bool openWindowOnActiveMonitor = false;
+    bool restoreSize = false;
+    bool quickLayoutSwitch = true;
+    bool flashZonesOnQuickSwitch = true;
+    bool use_cursorpos_editor_startupscreen = true;
+    bool showZonesOnAllMonitors = false;
+    bool spanZonesAcrossMonitors = false;
+    bool makeDraggedWindowTransparent = true;
+    std::wstring zoneColor = L"#AACDFF";
+    std::wstring zoneBorderColor = L"#FFFFFF";
+    std::wstring zoneHighlightColor = L"#008CFF";
+    int zoneHighlightOpacity = 50;
+    OverlappingZonesAlgorithm overlappingZonesAlgorithm = OverlappingZonesAlgorithm::Smallest;
+    PowerToysSettings::HotkeyObject editorHotkey = PowerToysSettings::HotkeyObject::from_settings(true, false, false, true, VK_OEM_3);
+    std::wstring excludedApps = L"";
+    std::vector<std::wstring> excludedAppsArray;
+};
+
+interface __declspec(uuid("{BA4E77C4-6F44-4C5D-93D3-CBDE880495C2}")) IFancyZonesSettings : public IUnknown
+{
+    IFACEMETHOD_(void, SetCallback)(interface IFancyZonesCallback* callback) = 0;
+    IFACEMETHOD_(void, ResetCallback)() = 0;
+    IFACEMETHOD_(bool, GetConfig)(_Out_ PWSTR buffer, _Out_ int *buffer_size) = 0;
+    IFACEMETHOD_(void, SetConfig)(PCWSTR serializedPowerToysSettings) = 0;
+    IFACEMETHOD_(void, ReloadSettings)() = 0;
+    IFACEMETHOD_(const Settings*, GetSettings)() const = 0;
+};
+
+winrt::com_ptr<IFancyZonesSettings> MakeFancyZonesSettings(HINSTANCE hinstance, PCWSTR name, PCWSTR key) noexcept;

src/modules/fancyzones/FancyZonesLib/VirtualDesktopUtils.cpp

@@ -0,0 +1,224 @@
+#include "pch.h"
+
+#include "VirtualDesktopUtils.h"
+
+// Non-Localizable strings
+namespace NonLocalizable
+{
+    const wchar_t RegCurrentVirtualDesktop[] = L"CurrentVirtualDesktop";
+    const wchar_t RegVirtualDesktopIds[] = L"VirtualDesktopIDs";
+    const wchar_t RegKeyVirtualDesktops[] = L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\VirtualDesktops";
+    const wchar_t RegKeyVirtualDesktopsFromSession[] = L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\SessionInfo\\%d\\VirtualDesktops";
+}
+
+namespace VirtualDesktopUtils
+{
+    const CLSID CLSID_ImmersiveShell = { 0xC2F03A33, 0x21F5, 0x47FA, 0xB4, 0xBB, 0x15, 0x63, 0x62, 0xA2, 0xF2, 0x39 };
+
+    IServiceProvider* GetServiceProvider()
+    {
+        IServiceProvider* provider{ nullptr };
+        if (FAILED(CoCreateInstance(CLSID_ImmersiveShell, nullptr, CLSCTX_LOCAL_SERVER, __uuidof(provider), (PVOID*)&provider)))
+        {
+            return nullptr;
+        }
+        return provider;
+    }
+
+    IVirtualDesktopManager* GetVirtualDesktopManager()
+    {
+        IVirtualDesktopManager* manager{ nullptr };
+        IServiceProvider* serviceProvider = GetServiceProvider();
+        if (serviceProvider == nullptr || FAILED(serviceProvider->QueryService(__uuidof(manager), &manager)))
+        {
+            return nullptr;
+        }
+        return manager;
+    }
+
+    bool GetWindowDesktopId(HWND topLevelWindow, GUID* desktopId)
+    {
+        static IVirtualDesktopManager* virtualDesktopManager = GetVirtualDesktopManager();
+        return (virtualDesktopManager != nullptr) &&
+               SUCCEEDED(virtualDesktopManager->GetWindowDesktopId(topLevelWindow, desktopId));
+    }
+
+    bool GetZoneWindowDesktopId(IZoneWindow* zoneWindow, GUID* desktopId)
+    {
+        // Format: <device-id>_<resolution>_<virtual-desktop-id>
+        std::wstring uniqueId = zoneWindow->UniqueId();
+        std::wstring virtualDesktopId = uniqueId.substr(uniqueId.rfind('_') + 1);
+        return SUCCEEDED(CLSIDFromString(virtualDesktopId.c_str(), desktopId));
+    }
+
+    bool NewGetCurrentDesktopId(GUID* desktopId)
+    {
+        wil::unique_hkey key{};
+        if (RegOpenKeyExW(HKEY_CURRENT_USER, NonLocalizable::RegKeyVirtualDesktops, 0, KEY_ALL_ACCESS, &key) == ERROR_SUCCESS)
+        {
+            GUID value{};
+            DWORD size = sizeof(GUID);
+            if (RegQueryValueExW(key.get(), NonLocalizable::RegCurrentVirtualDesktop, 0, nullptr, reinterpret_cast<BYTE*>(&value), &size) == ERROR_SUCCESS)
+            {
+                *desktopId = value;
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    bool GetDesktopIdFromCurrentSession(GUID* desktopId)
+    {
+        DWORD sessionId;
+        if (!ProcessIdToSessionId(GetCurrentProcessId(), &sessionId))
+        {
+            return false;
+        }
+
+        wchar_t sessionKeyPath[256]{};
+        if (FAILED(StringCchPrintfW(sessionKeyPath, ARRAYSIZE(sessionKeyPath), NonLocalizable::RegKeyVirtualDesktopsFromSession, sessionId)))
+        {
+            return false;
+        }
+
+        wil::unique_hkey key{};
+        if (RegOpenKeyExW(HKEY_CURRENT_USER, sessionKeyPath, 0, KEY_ALL_ACCESS, &key) == ERROR_SUCCESS)
+        {
+            GUID value{};
+            DWORD size = sizeof(GUID);
+            if (RegQueryValueExW(key.get(), NonLocalizable::RegCurrentVirtualDesktop, 0, nullptr, reinterpret_cast<BYTE*>(&value), &size) == ERROR_SUCCESS)
+            {
+                *desktopId = value;
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    bool GetCurrentVirtualDesktopId(GUID* desktopId)
+    {
+        // On newer Windows builds, the current virtual desktop is persisted to
+        // a totally different reg key. Look there first.
+        if (NewGetCurrentDesktopId(desktopId))
+        {
+            return true;
+        }
+
+        // Explorer persists current virtual desktop identifier to registry on a per session basis, but only
+        // after first virtual desktop switch happens. If the user hasn't switched virtual desktops in this
+        // session, value in registry will be empty.
+        if (GetDesktopIdFromCurrentSession(desktopId))
+        {
+            return true;
+        }
+        // Fallback scenario is to get array of virtual desktops stored in registry, but not kept per session.
+        // Note that we are taking first element from virtual desktop array, which is primary desktop.
+        // If user has more than one virtual desktop, previous function should return correct value, as desktop
+        // switch occurred in current session.
+        else
+        {
+            std::vector<GUID> ids{};
+            if (GetVirtualDesktopIds(ids) && ids.size() > 0)
+            {
+                *desktopId = ids[0];
+                return true;
+            }
+        }
+        return false;
+    }
+
+    bool GetVirtualDesktopIds(HKEY hKey, std::vector<GUID>& ids)
+    {
+        if (!hKey)
+        {
+            return false;
+        }
+        DWORD bufferCapacity;
+        // request regkey binary buffer capacity only
+        if (RegQueryValueExW(hKey, NonLocalizable::RegVirtualDesktopIds, 0, nullptr, nullptr, &bufferCapacity) != ERROR_SUCCESS)
+        {
+            return false;
+        }
+        std::unique_ptr<BYTE[]> buffer = std::make_unique<BYTE[]>(bufferCapacity);
+        // request regkey binary content
+        if (RegQueryValueExW(hKey, NonLocalizable::RegVirtualDesktopIds, 0, nullptr, buffer.get(), &bufferCapacity) != ERROR_SUCCESS)
+        {
+            return false;
+        }
+        const size_t guidSize = sizeof(GUID);
+        std::vector<GUID> temp;
+        temp.reserve(bufferCapacity / guidSize);
+        for (size_t i = 0; i < bufferCapacity; i += guidSize)
+        {
+            GUID* guid = reinterpret_cast<GUID*>(buffer.get() + i);
+            temp.push_back(*guid);
+        }
+        ids = std::move(temp);
+        return true;
+    }
+
+    bool GetVirtualDesktopIds(std::vector<GUID>& ids)
+    {
+        return GetVirtualDesktopIds(GetVirtualDesktopsRegKey(), ids);
+    }
+
+    bool GetVirtualDesktopIds(std::vector<std::wstring>& ids)
+    {
+        std::vector<GUID> guids{};
+        if (GetVirtualDesktopIds(guids))
+        {
+            for (auto& guid : guids)
+            {
+                wil::unique_cotaskmem_string guidString;
+                if (SUCCEEDED(StringFromCLSID(guid, &guidString)))
+                {
+                    ids.push_back(guidString.get());
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+
+    HKEY OpenVirtualDesktopsRegKey()
+    {
+        HKEY hKey{ nullptr };
+        if (RegOpenKeyEx(HKEY_CURRENT_USER, NonLocalizable::RegKeyVirtualDesktops, 0, KEY_ALL_ACCESS, &hKey) == ERROR_SUCCESS)
+        {
+            return hKey;
+        }
+        return nullptr;
+    }
+
+    HKEY GetVirtualDesktopsRegKey()
+    {
+        static wil::unique_hkey virtualDesktopsKey{ OpenVirtualDesktopsRegKey() };
+        return virtualDesktopsKey.get();
+    }
+
+    void HandleVirtualDesktopUpdates(HWND window, UINT message, HANDLE terminateEvent)
+    {
+        HKEY virtualDesktopsRegKey = GetVirtualDesktopsRegKey();
+        if (!virtualDesktopsRegKey)
+        {
+            return;
+        }
+        HANDLE regKeyEvent = CreateEvent(nullptr, FALSE, FALSE, nullptr);
+        HANDLE events[2] = { regKeyEvent, terminateEvent };
+        while (1)
+        {
+            if (RegNotifyChangeKeyValue(virtualDesktopsRegKey, TRUE, REG_NOTIFY_CHANGE_LAST_SET, regKeyEvent, TRUE) != ERROR_SUCCESS)
+            {
+                return;
+            }
+            if (WaitForMultipleObjects(2, events, FALSE, INFINITE) != (WAIT_OBJECT_0 + 0))
+            {
+                // if terminateEvent is signalized or WaitForMultipleObjects failed, terminate thread execution
+                return;
+            }
+            PostMessage(window, message, 0, 0);
+        }
+    }
+}

src/modules/fancyzones/FancyZonesLib/VirtualDesktopUtils.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "ZoneWindow.h"
+
+namespace VirtualDesktopUtils
+{
+    bool GetWindowDesktopId(HWND topLevelWindow, GUID* desktopId);
+    bool GetZoneWindowDesktopId(IZoneWindow* zoneWindow, GUID* desktopId);
+    bool GetCurrentVirtualDesktopId(GUID* desktopId);
+    bool GetVirtualDesktopIds(std::vector<GUID>& ids);
+    bool GetVirtualDesktopIds(std::vector<std::wstring>& ids);
+    HKEY GetVirtualDesktopsRegKey();
+    void HandleVirtualDesktopUpdates(HWND window, UINT message, HANDLE terminateEvent);
+}

src/modules/fancyzones/FancyZonesLib/WindowMoveHandler.cpp

@@ -0,0 +1,361 @@
+#include "pch.h"
+#include "WindowMoveHandler.h"
+
+#include <common/display/dpi_aware.h>
+#include <common/notifications/notifications.h>
+#include <common/notifications/dont_show_again.h>
+#include <common/utils/elevation.h>
+#include <common/utils/resources.h>
+
+#include "FancyZonesData.h"
+#include "Settings.h"
+#include "ZoneWindow.h"
+#include "util.h"
+
+// Non-Localizable strings
+namespace NonLocalizable
+{
+    const wchar_t FancyZonesRunAsAdminInfoPage[] = L"https://aka.ms/powertoysDetectedElevatedHelp";
+    const wchar_t ToastNotificationButtonUrl[] = L"powertoys://cant_drag_elevated_disable/";
+}
+
+namespace WindowMoveHandlerUtils
+{
+    bool IsCursorTypeIndicatingSizeEvent()
+    {
+        CURSORINFO cursorInfo = { 0 };
+        cursorInfo.cbSize = sizeof(cursorInfo);
+
+        if (::GetCursorInfo(&cursorInfo))
+        {
+            if (::LoadCursor(NULL, IDC_SIZENS) == cursorInfo.hCursor)
+            {
+                return true;
+            }
+            if (::LoadCursor(NULL, IDC_SIZEWE) == cursorInfo.hCursor)
+            {
+                return true;
+            }
+            if (::LoadCursor(NULL, IDC_SIZENESW) == cursorInfo.hCursor)
+            {
+                return true;
+            }
+            if (::LoadCursor(NULL, IDC_SIZENWSE) == cursorInfo.hCursor)
+            {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+
+WindowMoveHandler::WindowMoveHandler(const winrt::com_ptr<IFancyZonesSettings>& settings, const std::function<void()>& keyUpdateCallback) :
+    m_settings(settings),
+    m_mouseState(false),
+    m_mouseHook(std::bind(&WindowMoveHandler::OnMouseDown, this)),
+    m_shiftKeyState(keyUpdateCallback),
+    m_ctrlKeyState(keyUpdateCallback),
+    m_keyUpdateCallback(keyUpdateCallback)
+{
+}
+
+void WindowMoveHandler::MoveSizeStart(HWND window, HMONITOR monitor, POINT const& ptScreen, const std::unordered_map<HMONITOR, winrt::com_ptr<IZoneWindow>>& zoneWindowMap) noexcept
+{
+    if (!FancyZonesUtils::IsCandidateForZoning(window, m_settings->GetSettings()->excludedAppsArray) || WindowMoveHandlerUtils::IsCursorTypeIndicatingSizeEvent())
+    {
+        return;
+    }
+
+    m_moveSizeWindowInfo.hasNoVisibleOwner = FancyZonesUtils::HasNoVisibleOwner(window);
+    m_moveSizeWindowInfo.isStandardWindow = FancyZonesUtils::IsStandardWindow(window);
+    m_inMoveSize = true;
+
+    auto iter = zoneWindowMap.find(monitor);
+    if (iter == end(zoneWindowMap))
+    {
+        return;
+    }
+
+    m_windowMoveSize = window;
+
+    if (m_settings->GetSettings()->mouseSwitch)
+    {
+        m_mouseHook.enable();
+    }
+
+    m_shiftKeyState.enable();
+    m_ctrlKeyState.enable();
+
+    // This updates m_dragEnabled depending on if the shift key is being held down
+    UpdateDragState();
+
+    // Notifies user if unable to drag elevated window
+    WarnIfElevationIsRequired(window);
+
+    if (m_dragEnabled)
+    {
+        m_zoneWindowMoveSize = iter->second;
+        SetWindowTransparency(m_windowMoveSize);
+        m_zoneWindowMoveSize->MoveSizeEnter(m_windowMoveSize);
+        if (m_settings->GetSettings()->showZonesOnAllMonitors)
+        {
+            for (auto [keyMonitor, zoneWindow] : zoneWindowMap)
+            {
+                // Skip calling ShowZoneWindow for iter->second (m_zoneWindowMoveSize) since it
+                // was already called in MoveSizeEnter
+                const bool moveSizeEnterCalled = zoneWindow == m_zoneWindowMoveSize;
+                if (zoneWindow && !moveSizeEnterCalled)
+                {
+                    zoneWindow->ShowZoneWindow();
+                }
+            }
+        }
+    }
+    else if (m_zoneWindowMoveSize)
+    {
+        ResetWindowTransparency();
+        m_zoneWindowMoveSize = nullptr;
+        for (auto [keyMonitor, zoneWindow] : zoneWindowMap)
+        {
+            if (zoneWindow)
+            {
+                zoneWindow->HideZoneWindow();
+            }
+        }
+    }
+}
+
+void WindowMoveHandler::MoveSizeUpdate(HMONITOR monitor, POINT const& ptScreen, const std::unordered_map<HMONITOR, winrt::com_ptr<IZoneWindow>>& zoneWindowMap) noexcept
+{
+    if (!m_inMoveSize)
+    {
+        return;
+    }
+
+    // This updates m_dragEnabled depending on if the shift key is being held down.
+    UpdateDragState();
+
+    if (m_zoneWindowMoveSize)
+    {
+        // Update the ZoneWindow already handling move/size
+        if (!m_dragEnabled)
+        {
+            // Drag got disabled, tell it to cancel and hide all windows
+            m_zoneWindowMoveSize = nullptr;
+            ResetWindowTransparency();
+
+            for (auto [keyMonitor, zoneWindow] : zoneWindowMap)
+            {
+                if (zoneWindow)
+                {
+                    zoneWindow->HideZoneWindow();
+                }
+            }
+        }
+        else
+        {
+            auto iter = zoneWindowMap.find(monitor);
+            if (iter != zoneWindowMap.end())
+            {
+                if (iter->second != m_zoneWindowMoveSize)
+                {
+                    // The drag has moved to a different monitor.
+                    m_zoneWindowMoveSize->ClearSelectedZones();
+                    if (!m_settings->GetSettings()->showZonesOnAllMonitors)
+                    {
+                        m_zoneWindowMoveSize->HideZoneWindow();
+                    }
+
+                    m_zoneWindowMoveSize = iter->second;
+                    m_zoneWindowMoveSize->MoveSizeEnter(m_windowMoveSize);
+                }
+
+                for (auto [keyMonitor, zoneWindow] : zoneWindowMap)
+                {
+                    zoneWindow->MoveSizeUpdate(ptScreen, m_dragEnabled, m_ctrlKeyState.state());
+                }
+            }
+        }
+    }
+    else if (m_dragEnabled)
+    {
+        // We'll get here if the user presses/releases shift while dragging.
+        // Restart the drag on the ZoneWindow that m_windowMoveSize is on
+        MoveSizeStart(m_windowMoveSize, monitor, ptScreen, zoneWindowMap);
+
+        // m_dragEnabled could get set to false if we're moving an elevated window.
+        // In that case do not proceed.
+        if (m_dragEnabled)
+        {
+            MoveSizeUpdate(monitor, ptScreen, zoneWindowMap);
+        }
+    }
+}
+
+void WindowMoveHandler::MoveSizeEnd(HWND window, POINT const& ptScreen, const std::unordered_map<HMONITOR, winrt::com_ptr<IZoneWindow>>& zoneWindowMap) noexcept
+{
+    if (window != m_windowMoveSize)
+    {
+        return;
+    }
+
+    m_mouseHook.disable();
+    m_shiftKeyState.disable();
+    m_ctrlKeyState.disable();
+
+    if (m_zoneWindowMoveSize)
+    {
+        auto zoneWindow = std::move(m_zoneWindowMoveSize);
+        ResetWindowTransparency();
+
+        bool hasNoVisibleOwner = FancyZonesUtils::HasNoVisibleOwner(window);
+        bool isStandardWindow = FancyZonesUtils::IsStandardWindow(window);
+
+        if ((isStandardWindow == false && hasNoVisibleOwner == true &&
+             m_moveSizeWindowInfo.isStandardWindow == true && m_moveSizeWindowInfo.hasNoVisibleOwner == true) ||
+            FancyZonesUtils::IsWindowMaximized(window))
+        {
+            // Abort the zoning, this is a Chromium based tab that is merged back with an existing window
+            // or if the window is maximized by Windows when the cursor hits the screen top border
+        }
+        else
+        {
+            zoneWindow->MoveSizeEnd(m_windowMoveSize, ptScreen);
+        }
+    }
+    else
+    {
+        if (m_settings->GetSettings()->restoreSize)
+        {
+            if (WindowMoveHandlerUtils::IsCursorTypeIndicatingSizeEvent())
+            {
+                ::RemoveProp(window, ZonedWindowProperties::PropertyRestoreSizeID);
+            }
+            else if (!FancyZonesUtils::IsWindowMaximized(window))
+            {
+                FancyZonesUtils::RestoreWindowSize(window);
+            }
+        }
+
+        auto monitor = MonitorFromWindow(window, MONITOR_DEFAULTTONULL);
+        if (monitor)
+        {
+            auto zoneWindow = zoneWindowMap.find(monitor);
+            if (zoneWindow != zoneWindowMap.end())
+            {
+                const auto zoneWindowPtr = zoneWindow->second;
+                const auto activeZoneSet = zoneWindowPtr->ActiveZoneSet();
+                if (activeZoneSet)
+                {
+                    wil::unique_cotaskmem_string guidString;
+                    if (SUCCEEDED_LOG(StringFromCLSID(activeZoneSet->Id(), &guidString)))
+                    {
+                        FancyZonesDataInstance().RemoveAppLastZone(window, zoneWindowPtr->UniqueId(), guidString.get());
+                    }
+                }
+            }
+        }
+        ::RemoveProp(window, ZonedWindowProperties::PropertyMultipleZoneID);
+    }
+
+    m_inMoveSize = false;
+    m_dragEnabled = false;
+    m_mouseState = false;
+    m_windowMoveSize = nullptr;
+
+    // Also, hide all windows (regardless of settings)
+    for (auto [keyMonitor, zoneWindow] : zoneWindowMap)
+    {
+        if (zoneWindow)
+        {
+            zoneWindow->HideZoneWindow();
+        }
+    }
+}
+
+void WindowMoveHandler::MoveWindowIntoZoneByIndexSet(HWND window, const std::vector<size_t>& indexSet, winrt::com_ptr<IZoneWindow> zoneWindow) noexcept
+{
+    if (window != m_windowMoveSize)
+    {
+        zoneWindow->MoveWindowIntoZoneByIndexSet(window, indexSet);
+    }
+}
+
+bool WindowMoveHandler::MoveWindowIntoZoneByDirectionAndIndex(HWND window, DWORD vkCode, bool cycle, winrt::com_ptr<IZoneWindow> zoneWindow) noexcept
+{
+    return zoneWindow && zoneWindow->MoveWindowIntoZoneByDirectionAndIndex(window, vkCode, cycle);
+}
+
+bool WindowMoveHandler::MoveWindowIntoZoneByDirectionAndPosition(HWND window, DWORD vkCode, bool cycle, winrt::com_ptr<IZoneWindow> zoneWindow) noexcept
+{
+    return zoneWindow && zoneWindow->MoveWindowIntoZoneByDirectionAndPosition(window, vkCode, cycle);
+}
+
+bool WindowMoveHandler::ExtendWindowByDirectionAndPosition(HWND window, DWORD vkCode, winrt::com_ptr<IZoneWindow> zoneWindow) noexcept
+{
+    return zoneWindow && zoneWindow->ExtendWindowByDirectionAndPosition(window, vkCode);
+}
+
+void WindowMoveHandler::WarnIfElevationIsRequired(HWND window) noexcept
+{
+    using namespace notifications;
+    using namespace NonLocalizable;
+    using namespace FancyZonesUtils;
+
+    static bool warning_shown = false;
+    if (!is_process_elevated() && IsProcessOfWindowElevated(window))
+    {
+        m_dragEnabled = false;
+        if (!warning_shown && !is_toast_disabled(CantDragElevatedDontShowAgainRegistryPath, CantDragElevatedDisableIntervalInDays))
+        {
+            std::vector<action_t> actions = {
+                link_button{ GET_RESOURCE_STRING(IDS_CANT_DRAG_ELEVATED_LEARN_MORE), FancyZonesRunAsAdminInfoPage },
+                link_button{ GET_RESOURCE_STRING(IDS_CANT_DRAG_ELEVATED_DIALOG_DONT_SHOW_AGAIN), ToastNotificationButtonUrl }
+            };
+            show_toast_with_activations(GET_RESOURCE_STRING(IDS_CANT_DRAG_ELEVATED),
+                                        GET_RESOURCE_STRING(IDS_FANCYZONES),
+                                        {},
+                                        std::move(actions));
+            warning_shown = true;
+        }
+    }
+}
+
+void WindowMoveHandler::UpdateDragState() noexcept
+{
+    if (m_settings->GetSettings()->shiftDrag)
+    {
+        m_dragEnabled = (m_shiftKeyState.state() ^ m_mouseState);
+    }
+    else
+    {
+        m_dragEnabled = !(m_shiftKeyState.state() ^ m_mouseState);
+    }
+}
+
+void WindowMoveHandler::SetWindowTransparency(HWND window) noexcept
+{
+    if (m_settings->GetSettings()->makeDraggedWindowTransparent)
+    {
+        m_windowTransparencyProperties.draggedWindowExstyle = GetWindowLong(window, GWL_EXSTYLE);
+
+        m_windowTransparencyProperties.draggedWindow = window;
+        SetWindowLong(window,
+                      GWL_EXSTYLE,
+                      m_windowTransparencyProperties.draggedWindowExstyle | WS_EX_LAYERED);
+
+        GetLayeredWindowAttributes(window, &m_windowTransparencyProperties.draggedWindowCrKey, &m_windowTransparencyProperties.draggedWindowInitialAlpha, &m_windowTransparencyProperties.draggedWindowDwFlags);
+
+        SetLayeredWindowAttributes(window, 0, (255 * 50) / 100, LWA_ALPHA);
+    }
+}
+
+void WindowMoveHandler::ResetWindowTransparency() noexcept
+{
+    if (m_settings->GetSettings()->makeDraggedWindowTransparent && m_windowTransparencyProperties.draggedWindow != nullptr)
+    {
+        SetLayeredWindowAttributes(m_windowTransparencyProperties.draggedWindow, m_windowTransparencyProperties.draggedWindowCrKey, m_windowTransparencyProperties.draggedWindowInitialAlpha, m_windowTransparencyProperties.draggedWindowDwFlags);
+        SetWindowLong(m_windowTransparencyProperties.draggedWindow, GWL_EXSTYLE, m_windowTransparencyProperties.draggedWindowExstyle);
+        m_windowTransparencyProperties.draggedWindow = nullptr;
+    }
+}

src/modules/fancyzones/FancyZonesLib/WindowMoveHandler.h

@@ -0,0 +1,81 @@
+#pragma once
+
+#include "KeyState.h"
+#include "SecondaryMouseButtonsHook.h"
+
+#include <functional>
+
+interface IFancyZonesSettings;
+interface IZoneWindow;
+
+class WindowMoveHandler
+{
+public:
+    WindowMoveHandler(const winrt::com_ptr<IFancyZonesSettings>& settings, const std::function<void()>& keyUpdateCallback);
+
+    void MoveSizeStart(HWND window, HMONITOR monitor, POINT const& ptScreen, const std::unordered_map<HMONITOR, winrt::com_ptr<IZoneWindow>>& zoneWindowMap) noexcept;
+    void MoveSizeUpdate(HMONITOR monitor, POINT const& ptScreen, const std::unordered_map<HMONITOR, winrt::com_ptr<IZoneWindow>>& zoneWindowMap) noexcept;
+    void MoveSizeEnd(HWND window, POINT const& ptScreen, const std::unordered_map<HMONITOR, winrt::com_ptr<IZoneWindow>>& zoneWindowMap) noexcept;
+
+    void MoveWindowIntoZoneByIndexSet(HWND window, const std::vector<size_t>& indexSet, winrt::com_ptr<IZoneWindow> zoneWindow) noexcept;
+    bool MoveWindowIntoZoneByDirectionAndIndex(HWND window, DWORD vkCode, bool cycle, winrt::com_ptr<IZoneWindow> zoneWindow) noexcept;
+    bool MoveWindowIntoZoneByDirectionAndPosition(HWND window, DWORD vkCode, bool cycle, winrt::com_ptr<IZoneWindow> zoneWindow) noexcept;
+    bool ExtendWindowByDirectionAndPosition(HWND window, DWORD vkCode, winrt::com_ptr<IZoneWindow> zoneWindow) noexcept;
+
+    inline void OnMouseDown() noexcept
+    {
+        m_mouseState = !m_mouseState;
+        m_keyUpdateCallback();
+    }
+
+    inline bool IsDragEnabled() const noexcept
+    {
+        return m_dragEnabled;
+    }
+
+    inline bool InMoveSize() const noexcept
+    {
+        return m_inMoveSize;
+    }
+
+private:
+    struct WindowTransparencyProperties
+    {
+        HWND draggedWindow = nullptr;
+        long draggedWindowExstyle = 0;
+        COLORREF draggedWindowCrKey = RGB(0, 0, 0);
+        DWORD draggedWindowDwFlags = 0;
+        BYTE draggedWindowInitialAlpha = 0;
+    };
+
+    // MoveSize related window properties
+    struct MoveSizeWindowInfo
+    {
+        // True if from the styles the window looks like a standard window
+        bool isStandardWindow = false;
+        // True if the window is a top-level window that does not have a visible owner
+        bool hasNoVisibleOwner = false;
+    };
+
+    void WarnIfElevationIsRequired(HWND window) noexcept;
+    void UpdateDragState() noexcept;
+
+    void SetWindowTransparency(HWND window) noexcept;
+    void ResetWindowTransparency() noexcept;
+
+    winrt::com_ptr<IFancyZonesSettings> m_settings{};
+
+    HWND m_windowMoveSize{}; // The window that is being moved/sized
+    bool m_inMoveSize{}; // Whether or not a move/size operation is currently active
+    MoveSizeWindowInfo m_moveSizeWindowInfo; // MoveSizeWindowInfo of the window at the moment when dragging started
+    winrt::com_ptr<IZoneWindow> m_zoneWindowMoveSize; // "Active" ZoneWindow, where the move/size is happening. Will update as drag moves between monitors.
+    bool m_dragEnabled{}; // True if we should be showing zone hints while dragging
+
+    WindowTransparencyProperties m_windowTransparencyProperties;
+
+    std::atomic<bool> m_mouseState;
+    SecondaryMouseButtonsHook m_mouseHook;
+    KeyState<VK_LSHIFT, VK_RSHIFT> m_shiftKeyState;
+    KeyState<VK_LCONTROL, VK_RCONTROL> m_ctrlKeyState;
+    std::function<void()> m_keyUpdateCallback;
+};

src/modules/fancyzones/FancyZonesLib/Zone.cpp

@@ -0,0 +1,88 @@
+#include "pch.h"
+
+
+#include <Shellscalingapi.h>
+
+#include <common/display/dpi_aware.h>
+#include <common/display/monitors.h>
+#include "Zone.h"
+#include "Settings.h"
+#include "util.h"
+
+namespace
+{
+    bool ValidateZoneRect(const RECT& rect)
+    {
+        int width  = rect.right - rect.left;
+        int height = rect.bottom - rect.top;
+        return rect.left   >= ZoneConstants::MAX_NEGATIVE_SPACING &&
+               rect.right  >= ZoneConstants::MAX_NEGATIVE_SPACING &&
+               rect.top    >= ZoneConstants::MAX_NEGATIVE_SPACING &&
+               rect.bottom >= ZoneConstants::MAX_NEGATIVE_SPACING &&
+               width >= 0 && height >= 0;
+    }
+}
+
+struct Zone : winrt::implements<Zone, IZone>
+{
+public:
+    Zone(RECT zoneRect, const size_t zoneId) :
+        m_zoneRect(zoneRect),
+        m_id(zoneId)
+    {
+    }
+
+    IFACEMETHODIMP_(RECT) GetZoneRect() const noexcept { return m_zoneRect; }
+    IFACEMETHODIMP_(long) GetZoneArea() const noexcept { return max(m_zoneRect.bottom - m_zoneRect.top, 0) * max(m_zoneRect.right - m_zoneRect.left, 0); }
+    IFACEMETHODIMP_(size_t) Id() const noexcept { return m_id; }
+    IFACEMETHODIMP_(RECT) ComputeActualZoneRect(HWND window, HWND zoneWindow) const noexcept;
+
+private:
+    RECT m_zoneRect{};
+    const size_t m_id{};
+    std::map<HWND, RECT> m_windows{};
+};
+
+RECT Zone::ComputeActualZoneRect(HWND window, HWND zoneWindow) const noexcept
+{
+    // Take care of 1px border
+    RECT newWindowRect = m_zoneRect;
+
+    RECT windowRect{};
+    ::GetWindowRect(window, &windowRect);
+
+    RECT frameRect{};
+
+    if (SUCCEEDED(DwmGetWindowAttribute(window, DWMWA_EXTENDED_FRAME_BOUNDS, &frameRect, sizeof(frameRect))))
+    {
+        LONG leftMargin = frameRect.left - windowRect.left;
+        LONG rightMargin = frameRect.right - windowRect.right;
+        LONG bottomMargin = frameRect.bottom - windowRect.bottom;
+        newWindowRect.left -= leftMargin;
+        newWindowRect.right -= rightMargin;
+        newWindowRect.bottom -= bottomMargin;
+    }
+
+    // Map to screen coords
+    MapWindowRect(zoneWindow, nullptr, &newWindowRect);
+
+    if ((::GetWindowLong(window, GWL_STYLE) & WS_SIZEBOX) == 0)
+    {
+        newWindowRect.right = newWindowRect.left + (windowRect.right - windowRect.left);
+        newWindowRect.bottom = newWindowRect.top + (windowRect.bottom - windowRect.top);
+    }
+
+    return newWindowRect;
+}
+
+winrt::com_ptr<IZone> MakeZone(const RECT& zoneRect, const size_t zoneId) noexcept
+{
+    if (ValidateZoneRect(zoneRect) && zoneId >= 0)
+    {
+        return winrt::make_self<Zone>(zoneRect, zoneId);
+    }
+    else
+    {
+        return nullptr;
+    }
+}

src/modules/fancyzones/FancyZonesLib/Zone.h

@@ -0,0 +1,37 @@
+#pragma once
+
+namespace ZoneConstants
+{
+    constexpr int MAX_NEGATIVE_SPACING = -10;
+}
+
+/**
+ * Class representing one zone inside applied zone layout, which is basically wrapper around rectangle structure.
+ */
+interface __declspec(uuid("{8228E934-B6EF-402A-9892-15A1441BF8B0}")) IZone : public IUnknown
+{
+    /**
+     * @returns Zone coordinates (top-left and bottom-right corner) represented as RECT structure.
+     */
+    IFACEMETHOD_(RECT, GetZoneRect)() const = 0;
+    /**
+     * @returns Zone area calculated from zone rect
+     */
+    IFACEMETHOD_(long, GetZoneArea)() const = 0;
+    /**
+     * @returns Zone identifier.
+     */
+    IFACEMETHOD_(size_t, Id)() const = 0;
+    /**
+     * Compute the coordinates of the rectangle to which a window should be resized.
+     *
+     * @param   window     Handle of window which should be assigned to zone.
+     * @param   zoneWindow The m_window of a ZoneWindow, it's a hidden window representing the
+     *                     current monitor desktop work area.
+     * @returns a RECT structure, describing global coordinates to which a window should be resized
+     */
+    IFACEMETHOD_(RECT, ComputeActualZoneRect)(HWND window, HWND zoneWindow) const = 0;
+
+};
+
+winrt::com_ptr<IZone> MakeZone(const RECT& zoneRect, const size_t zoneId) noexcept;

src/modules/fancyzones/FancyZonesLib/ZoneSet.h

@@ -0,0 +1,178 @@
+#pragma once
+
+#include "Zone.h"
+#include "Settings.h"
+
+namespace FancyZonesDataTypes
+{
+    enum class ZoneSetLayoutType;
+}
+/**
+ * Class representing single zone layout. ZoneSet is responsible for actual calculation of rectangle coordinates
+ * (whether is grid or canvas layout) and moving windows through them.
+ */
+interface __declspec(uuid("{E4839EB7-669D-49CF-84A9-71A2DFD851A3}")) IZoneSet : public IUnknown
+{
+    // Mapping zone id to zone
+    using ZonesMap = std::map<size_t, winrt::com_ptr<IZone>>;
+
+    /**
+     * @returns Unique identifier of zone layout.
+     */
+    IFACEMETHOD_(GUID, Id)() const = 0;
+    /**
+     * @returns Type of the zone layout. Layout type can be focus, columns, rows, grid, priority grid or custom.
+     */
+    IFACEMETHOD_(FancyZonesDataTypes::ZoneSetLayoutType, LayoutType)() const = 0;
+    /**
+     * Add zone to the zone layout.
+     *
+     * @param   zone Zone object (defining coordinates of the zone).
+     */
+    IFACEMETHOD(AddZone)(winrt::com_ptr<IZone> zone) = 0;
+    /**
+     * Get zones from cursor coordinates.
+     *
+     * @param   pt Cursor coordinates.
+     * @returns Vector of indices, corresponding to the current set of zones - the zones considered active.
+     */
+    IFACEMETHOD_(std::vector<size_t>, ZonesFromPoint)(POINT pt) const = 0;
+    /**
+     * Get index set of the zones to which the window was assigned.
+     *
+     * @param   window Handle of the window.
+     * @returns A vector of size_t, 0-based index set.
+     */
+    IFACEMETHOD_(std::vector<size_t>, GetZoneIndexSetFromWindow)
+    (HWND window) const = 0;
+    /**
+     * @returns Array of zone objects (defining coordinates of the zone) inside this zone layout.
+     */
+    IFACEMETHOD_(ZonesMap, GetZones) () const = 0;
+    /**
+     * Assign window to the zone based on zone index inside zone layout.
+     *
+     * @param   window         Handle of window which should be assigned to zone.
+     * @param   workAreaWindow The m_window of a ZoneWindow, it's a hidden window representing the
+     *                         current monitor desktop work area.
+     * @param   index          Zone index within zone layout.
+     */
+    IFACEMETHOD_(void, MoveWindowIntoZoneByIndex)
+    (HWND window, HWND workAreaWindow, size_t index) = 0;
+    /**
+     * Assign window to the zones based on the set of zone indices inside zone layout.
+     *
+     * @param   window         Handle of window which should be assigned to zone.
+     * @param   workAreaWindow The m_window of a ZoneWindow, it's a hidden window representing the
+     *                         current monitor desktop work area.
+     * @param   indexSet       The set of zone indices within zone layout.
+     */
+    IFACEMETHOD_(void, MoveWindowIntoZoneByIndexSet)
+    (HWND window, HWND workAreaWindow, const std::vector<size_t>& indexSet) = 0;
+    /**
+     * Assign window to the zone based on direction (using WIN + LEFT/RIGHT arrow), based on zone index numbers,
+     * not their on-screen position.
+     *
+     * @param   window         Handle of window which should be assigned to zone.
+     * @param   workAreaWindow The m_window of a ZoneWindow, it's a hidden window representing the
+     *                         current monitor desktop work area.
+     * @param   vkCode         Pressed arrow key.
+     * @param   cycle          Whether we should move window to the first zone if we reached last zone in layout.
+     *
+     * @returns Boolean which is always true if cycle argument is set, otherwise indicating if there is more
+     *          zones left in the zone layout in which window can move.
+     */
+    IFACEMETHOD_(bool, MoveWindowIntoZoneByDirectionAndIndex)
+    (HWND window, HWND workAreaWindow, DWORD vkCode, bool cycle) = 0;
+    /**
+     * Assign window to the zone based on direction (using WIN + LEFT/RIGHT/UP/DOWN arrow), based on
+     * their on-screen position.
+     *
+     * @param   window         Handle of window which should be assigned to zone.
+     * @param   workAreaWindow The m_window of a ZoneWindow, it's a hidden window representing the
+     *                         current monitor desktop work area.
+     * @param   vkCode         Pressed arrow key.
+     * @param   cycle          Whether we should move window to the first zone if we reached last zone in layout.
+     *
+     * @returns Boolean which is always true if cycle argument is set, otherwise indicating if there is more
+     *          zones left in the zone layout in which window can move.
+     */
+    IFACEMETHOD_(bool, MoveWindowIntoZoneByDirectionAndPosition)
+    (HWND window, HWND workAreaWindow, DWORD vkCode, bool cycle) = 0;
+    /**
+     * Extend or shrink the window to an adjacent zone based on direction (using CTRL+WIN+ALT + LEFT/RIGHT/UP/DOWN arrow), based on
+     * their on-screen position.
+     *
+     * @param   window         Handle of window which should be assigned to zone.
+     * @param   workAreaWindow The m_window of a ZoneWindow, it's a hidden window representing the
+     *                         current monitor desktop work area.
+     * @param   vkCode         Pressed arrow key.
+     *
+     * @returns Boolean indicating whether the window was rezoned. False could be returned when there are no more
+     *          zones available in the given direction.
+     */
+    IFACEMETHOD_(bool, ExtendWindowByDirectionAndPosition)
+    (HWND window, HWND workAreaWindow, DWORD vkCode) = 0;
+    /**
+     * Assign window to the zone based on cursor coordinates.
+     *
+     * @param   window         Handle of window which should be assigned to zone.
+     * @param   workAreaWindow The m_window of a ZoneWindow, it's a hidden window representing the
+     *                         current monitor desktop work area.
+     * @param   pt             Cursor coordinates.
+     */
+    IFACEMETHOD_(void, MoveWindowIntoZoneByPoint)
+    (HWND window, HWND workAreaWindow, POINT ptClient) = 0;
+    /**
+     * Calculate zone coordinates within zone layout based on number of zones and spacing.
+     *
+     * @param   workAreaRect The rectangular area on the screen on which the zone layout is applied.
+     * @param   zoneCount    Number of zones inside zone layout.
+     * @param   spacing      Spacing between zones in pixels.
+     *
+     * @returns Boolean indicating if calculation was successful.
+     */
+    IFACEMETHOD_(bool, CalculateZones)(RECT workAreaRect, int zoneCount, int spacing) = 0;
+    /**
+     * Check if the zone with the specified index is empty. Returns true if the zone with passed zoneIndex does not exist.
+     * 
+     * @param   zoneIndex   The index of of the zone within this zone set.
+     *
+     * @returns Boolean indicating whether the zone is empty.
+     */
+    IFACEMETHOD_(bool, IsZoneEmpty)(int zoneIndex) const = 0;
+    /**
+     * Returns all zones spanned by the minimum bounding rectangle containing the two given zone index sets.
+     * 
+     * @param   initialZones   The indices of the first chosen zone (the anchor).
+     * @param   finalZones     The indices of the last chosen zone (the current window position).
+     *
+     * @returns A vector indicating describing the chosen zone index set.
+     */
+    IFACEMETHOD_(std::vector<size_t>, GetCombinedZoneRange)(const std::vector<size_t>& initialZones, const std::vector<size_t>& finalZones) const = 0;
+};
+
+struct ZoneSetConfig
+{
+    ZoneSetConfig(
+        GUID id,
+        FancyZonesDataTypes::ZoneSetLayoutType layoutType,
+        HMONITOR monitor,
+        int sensitivityRadius,
+        Settings::OverlappingZonesAlgorithm selectionAlgorithm = {}) noexcept :
+            Id(id),
+            LayoutType(layoutType),
+            Monitor(monitor),
+            SensitivityRadius(sensitivityRadius),
+            SelectionAlgorithm(selectionAlgorithm)
+    {
+    }
+
+    GUID Id{};
+    FancyZonesDataTypes::ZoneSetLayoutType LayoutType{};
+    HMONITOR Monitor{};
+    int SensitivityRadius;
+    Settings::OverlappingZonesAlgorithm SelectionAlgorithm = Settings::OverlappingZonesAlgorithm::Smallest;
+};
+
+winrt::com_ptr<IZoneSet> MakeZoneSet(ZoneSetConfig const& config) noexcept;

src/modules/fancyzones/FancyZonesLib/ZoneWindow.cpp

@@ -0,0 +1,595 @@
+#include "pch.h"
+
+#include <common/logger/logger.h>
+
+#include "FancyZonesData.h"
+#include "FancyZonesDataTypes.h"
+#include "ZoneWindow.h"
+#include "ZoneWindowDrawing.h"
+#include "trace.h"
+#include "util.h"
+#include "on_thread_executor.h"
+#include "Settings.h"
+#include "CallTracer.h"
+
+#include <ShellScalingApi.h>
+#include <mutex>
+#include <fileapi.h>
+
+#include <gdiplus.h>
+
+// Non-Localizable strings
+namespace NonLocalizable
+{
+    const wchar_t ToolWindowClassName[] = L"SuperFancyZones_ZoneWindow";
+}
+
+using namespace FancyZonesUtils;
+
+struct ZoneWindow;
+
+namespace
+{
+    // The reason for using this class is the need to call ShowWindow(window, SW_SHOWNORMAL); on each
+    // newly created window for it to be displayed properly. The call sometimes has side effects when
+    // a fullscreen app is running, and happens when the resolution change event is triggered
+    // (e.g. when running some games).
+    // This class will serve as a pool of windows for which this call was already done.
+    class WindowPool
+    {
+        std::vector<HWND> m_pool;
+        std::mutex m_mutex;
+
+        HWND ExtractWindow()
+        {
+            _TRACER_;
+            std::unique_lock lock(m_mutex);
+
+            if (m_pool.empty())
+            {
+                return NULL;
+            }
+
+            HWND window = m_pool.back();
+            m_pool.pop_back();
+            return window;
+        }
+
+    public:
+
+        HWND NewZoneWindow(Rect position, HINSTANCE hinstance, ZoneWindow* owner)
+        {
+            HWND windowFromPool = ExtractWindow();
+            if (windowFromPool == NULL)
+            {
+                HWND window = CreateWindowExW(WS_EX_TOOLWINDOW, NonLocalizable::ToolWindowClassName, L"", WS_POPUP, position.left(), position.top(), position.width(), position.height(), nullptr, nullptr, hinstance, owner);
+                Logger::info("Creating new zone window, hWnd = {}", (void*)window);
+                MakeWindowTransparent(window);
+
+                // According to ShowWindow docs, we must call it with SW_SHOWNORMAL the first time
+                ShowWindow(window, SW_SHOWNORMAL);
+                ShowWindow(window, SW_HIDE);
+                return window;
+            }
+            else
+            {
+                Logger::info("Reusing zone window from pool, hWnd = {}", (void*)windowFromPool);
+                SetWindowLongPtrW(windowFromPool, GWLP_USERDATA, reinterpret_cast<LONG_PTR>(owner));
+                MoveWindow(windowFromPool, position.left(), position.top(), position.width(), position.height(), TRUE);
+                return windowFromPool;
+            }
+        }
+
+        void FreeZoneWindow(HWND window)
+        {
+            _TRACER_;
+            Logger::info("Freeing zone window, hWnd = {}", (void*)window);
+            SetWindowLongPtrW(window, GWLP_USERDATA, 0);
+            ShowWindow(window, SW_HIDE);
+
+            std::unique_lock lock(m_mutex);
+            m_pool.push_back(window);
+        }
+
+        ~WindowPool()
+        {
+            for (HWND window : m_pool)
+            {
+                DestroyWindow(window);
+            }
+        }
+    };
+
+    WindowPool windowPool;
+}
+
+struct ZoneWindow : public winrt::implements<ZoneWindow, IZoneWindow>
+{
+public:
+    ZoneWindow(HINSTANCE hinstance);
+    ~ZoneWindow();
+
+    bool Init(IZoneWindowHost* host, HINSTANCE hinstance, HMONITOR monitor, const std::wstring& uniqueId, const std::wstring& parentUniqueId);
+
+    IFACEMETHODIMP MoveSizeEnter(HWND window) noexcept;
+    IFACEMETHODIMP MoveSizeUpdate(POINT const& ptScreen, bool dragEnabled, bool selectManyZones) noexcept;
+    IFACEMETHODIMP MoveSizeEnd(HWND window, POINT const& ptScreen) noexcept;
+    IFACEMETHODIMP_(void)
+    MoveWindowIntoZoneByIndex(HWND window, size_t index) noexcept;
+    IFACEMETHODIMP_(void)
+    MoveWindowIntoZoneByIndexSet(HWND window, const std::vector<size_t>& indexSet) noexcept;
+    IFACEMETHODIMP_(bool)
+    MoveWindowIntoZoneByDirectionAndIndex(HWND window, DWORD vkCode, bool cycle) noexcept;
+    IFACEMETHODIMP_(bool)
+    MoveWindowIntoZoneByDirectionAndPosition(HWND window, DWORD vkCode, bool cycle) noexcept;
+    IFACEMETHODIMP_(bool)
+    ExtendWindowByDirectionAndPosition(HWND window, DWORD vkCode) noexcept;
+    IFACEMETHODIMP_(std::wstring)
+    UniqueId() noexcept { return { m_uniqueId }; }
+    IFACEMETHODIMP_(void)
+    SaveWindowProcessToZoneIndex(HWND window) noexcept;
+    IFACEMETHODIMP_(IZoneSet*)
+    ActiveZoneSet() noexcept { return m_activeZoneSet.get(); }
+    IFACEMETHODIMP_(void)
+    ShowZoneWindow() noexcept;
+    IFACEMETHODIMP_(void)
+    HideZoneWindow() noexcept;
+    IFACEMETHODIMP_(void)
+    UpdateActiveZoneSet() noexcept;
+    IFACEMETHODIMP_(void)
+    ClearSelectedZones() noexcept;
+    IFACEMETHODIMP_(void)
+    FlashZones() noexcept;
+
+protected:
+    static LRESULT CALLBACK s_WndProc(HWND window, UINT message, WPARAM wparam, LPARAM lparam) noexcept;
+
+private:
+    void InitializeZoneSets(const std::wstring& parentUniqueId) noexcept;
+    void CalculateZoneSet() noexcept;
+    void UpdateActiveZoneSet(_In_opt_ IZoneSet* zoneSet) noexcept;
+    LRESULT WndProc(UINT message, WPARAM wparam, LPARAM lparam) noexcept;
+    std::vector<size_t> ZonesFromPoint(POINT pt) noexcept;
+    void SetAsTopmostWindow() noexcept;
+
+    winrt::com_ptr<IZoneWindowHost> m_host;
+    HMONITOR m_monitor{};
+    std::wstring m_uniqueId; // Parsed deviceId + resolution + virtualDesktopId
+    HWND m_window{}; // Hidden tool window used to represent current monitor desktop work area.
+    HWND m_windowMoveSize{};
+    winrt::com_ptr<IZoneSet> m_activeZoneSet;
+    std::vector<winrt::com_ptr<IZoneSet>> m_zoneSets;
+    std::vector<size_t> m_initialHighlightZone;
+    std::vector<size_t> m_highlightZone;
+    WPARAM m_keyLast{};
+    size_t m_keyCycle{};
+    std::unique_ptr<ZoneWindowDrawing> m_zoneWindowDrawing;
+};
+
+ZoneWindow::ZoneWindow(HINSTANCE hinstance)
+{
+    WNDCLASSEXW wcex{};
+    wcex.cbSize = sizeof(WNDCLASSEX);
+    wcex.lpfnWndProc = s_WndProc;
+    wcex.hInstance = hinstance;
+    wcex.lpszClassName = NonLocalizable::ToolWindowClassName;
+    wcex.hCursor = LoadCursorW(nullptr, IDC_ARROW);
+    RegisterClassExW(&wcex);
+}
+
+ZoneWindow::~ZoneWindow()
+{
+    windowPool.FreeZoneWindow(m_window);
+}
+
+bool ZoneWindow::Init(IZoneWindowHost* host, HINSTANCE hinstance, HMONITOR monitor, const std::wstring& uniqueId, const std::wstring& parentUniqueId)
+{
+    m_host.copy_from(host);
+
+    Rect workAreaRect;
+    m_monitor = monitor;
+    if (monitor)
+    {
+        MONITORINFO mi{};
+        mi.cbSize = sizeof(mi);
+        if (!GetMonitorInfoW(monitor, &mi))
+        {
+            return false;
+        }
+        workAreaRect = Rect(mi.rcWork);
+    }
+    else
+    {
+        workAreaRect = GetAllMonitorsCombinedRect<&MONITORINFO::rcWork>();
+    }
+
+    m_uniqueId = uniqueId;
+    InitializeZoneSets(parentUniqueId);
+
+    m_window = windowPool.NewZoneWindow(workAreaRect, hinstance, this);
+
+    if (!m_window)
+    {
+        return false;
+    }
+
+    m_zoneWindowDrawing = std::make_unique<ZoneWindowDrawing>(m_window);
+
+    return true;
+}
+
+IFACEMETHODIMP ZoneWindow::MoveSizeEnter(HWND window) noexcept
+{
+    m_windowMoveSize = window;
+    m_highlightZone = {};
+    m_initialHighlightZone = {};
+    ShowZoneWindow();
+    return S_OK;
+}
+
+IFACEMETHODIMP ZoneWindow::MoveSizeUpdate(POINT const& ptScreen, bool dragEnabled, bool selectManyZones) noexcept
+{
+    bool redraw = false;
+    POINT ptClient = ptScreen;
+    MapWindowPoints(nullptr, m_window, &ptClient, 1);
+
+    if (dragEnabled)
+    {
+        auto highlightZone = ZonesFromPoint(ptClient);
+
+        if (selectManyZones)
+        {
+            if (m_initialHighlightZone.empty())
+            {
+                // first time
+                m_initialHighlightZone = highlightZone;
+            }
+            else
+            {
+                highlightZone = m_activeZoneSet->GetCombinedZoneRange(m_initialHighlightZone, highlightZone);
+            }
+        }
+        else
+        {
+            m_initialHighlightZone = {};
+        }
+
+        redraw = (highlightZone != m_highlightZone);
+        m_highlightZone = std::move(highlightZone);
+    }
+    else if (m_highlightZone.size())
+    {
+        m_highlightZone = {};
+        redraw = true;
+    }
+
+    if (redraw)
+    {
+        m_zoneWindowDrawing->DrawActiveZoneSet(m_activeZoneSet->GetZones(), m_highlightZone, m_host);
+    }
+
+    return S_OK;
+}
+
+IFACEMETHODIMP ZoneWindow::MoveSizeEnd(HWND window, POINT const& ptScreen) noexcept
+{
+    if (m_windowMoveSize != window)
+    {
+        return E_INVALIDARG;
+    }
+
+    if (m_activeZoneSet)
+    {
+        POINT ptClient = ptScreen;
+        MapWindowPoints(nullptr, m_window, &ptClient, 1);
+        m_activeZoneSet->MoveWindowIntoZoneByIndexSet(window, m_window, m_highlightZone);
+
+        if (FancyZonesUtils::HasNoVisibleOwner(window))
+        {
+            SaveWindowProcessToZoneIndex(window);
+        }
+    }
+    Trace::ZoneWindow::MoveSizeEnd(m_activeZoneSet);
+
+    HideZoneWindow();
+    m_windowMoveSize = nullptr;
+    return S_OK;
+}
+
+IFACEMETHODIMP_(void)
+ZoneWindow::MoveWindowIntoZoneByIndex(HWND window, size_t index) noexcept
+{
+    MoveWindowIntoZoneByIndexSet(window, { index });
+}
+
+IFACEMETHODIMP_(void)
+ZoneWindow::MoveWindowIntoZoneByIndexSet(HWND window, const std::vector<size_t>& indexSet) noexcept
+{
+    if (m_activeZoneSet)
+    {
+        m_activeZoneSet->MoveWindowIntoZoneByIndexSet(window, m_window, indexSet);
+    }
+}
+
+IFACEMETHODIMP_(bool)
+ZoneWindow::MoveWindowIntoZoneByDirectionAndIndex(HWND window, DWORD vkCode, bool cycle) noexcept
+{
+    if (m_activeZoneSet)
+    {
+        if (m_activeZoneSet->MoveWindowIntoZoneByDirectionAndIndex(window, m_window, vkCode, cycle))
+        {
+            if (FancyZonesUtils::HasNoVisibleOwner(window))
+            {
+                SaveWindowProcessToZoneIndex(window);
+            }
+            return true;
+        }
+    }
+    return false;
+}
+
+IFACEMETHODIMP_(bool)
+ZoneWindow::MoveWindowIntoZoneByDirectionAndPosition(HWND window, DWORD vkCode, bool cycle) noexcept
+{
+    if (m_activeZoneSet)
+    {
+        if (m_activeZoneSet->MoveWindowIntoZoneByDirectionAndPosition(window, m_window, vkCode, cycle))
+        {
+            SaveWindowProcessToZoneIndex(window);
+            return true;
+        }
+    }
+    return false;
+}
+
+IFACEMETHODIMP_(bool)
+ZoneWindow::ExtendWindowByDirectionAndPosition(HWND window, DWORD vkCode) noexcept
+{
+    if (m_activeZoneSet)
+    {
+        if (m_activeZoneSet->ExtendWindowByDirectionAndPosition(window, m_window, vkCode))
+        {
+            SaveWindowProcessToZoneIndex(window);
+            return true;
+        }
+    }
+    return false;
+}
+
+IFACEMETHODIMP_(void)
+ZoneWindow::SaveWindowProcessToZoneIndex(HWND window) noexcept
+{
+    if (m_activeZoneSet)
+    {
+        auto zoneIndexSet = m_activeZoneSet->GetZoneIndexSetFromWindow(window);
+        if (zoneIndexSet.size())
+        {
+            OLECHAR* guidString;
+            if (StringFromCLSID(m_activeZoneSet->Id(), &guidString) == S_OK)
+            {
+                FancyZonesDataInstance().SetAppLastZones(window, m_uniqueId, guidString, zoneIndexSet);
+            }
+
+            CoTaskMemFree(guidString);
+        }
+    }
+}
+
+IFACEMETHODIMP_(void)
+ZoneWindow::ShowZoneWindow() noexcept
+{
+    if (m_window)
+    {
+        SetAsTopmostWindow();
+        m_zoneWindowDrawing->DrawActiveZoneSet(m_activeZoneSet->GetZones(), m_highlightZone, m_host);
+        m_zoneWindowDrawing->Show();
+    }
+}
+
+IFACEMETHODIMP_(void)
+ZoneWindow::HideZoneWindow() noexcept
+{
+    if (m_window)
+    {
+        m_zoneWindowDrawing->Hide();
+        m_keyLast = 0;
+        m_windowMoveSize = nullptr;
+        m_highlightZone = {};
+    }
+}
+
+IFACEMETHODIMP_(void)
+ZoneWindow::UpdateActiveZoneSet() noexcept
+{
+    CalculateZoneSet();
+    if (m_window)
+    {
+        m_highlightZone.clear();
+        m_zoneWindowDrawing->DrawActiveZoneSet(m_activeZoneSet->GetZones(), m_highlightZone, m_host);
+    }
+}
+
+IFACEMETHODIMP_(void)
+ZoneWindow::ClearSelectedZones() noexcept
+{
+    if (m_highlightZone.size())
+    {
+        m_highlightZone.clear();
+        m_zoneWindowDrawing->DrawActiveZoneSet(m_activeZoneSet->GetZones(), m_highlightZone, m_host);
+    }
+}
+
+IFACEMETHODIMP_(void)
+ZoneWindow::FlashZones() noexcept
+{
+    if (m_window)
+    {
+        SetAsTopmostWindow();
+        m_zoneWindowDrawing->DrawActiveZoneSet(m_activeZoneSet->GetZones(), {}, m_host);
+        m_zoneWindowDrawing->Flash();
+    }
+}
+
+#pragma region private
+
+void ZoneWindow::InitializeZoneSets(const std::wstring& parentUniqueId) noexcept
+{
+    bool deviceAdded = FancyZonesDataInstance().AddDevice(m_uniqueId);
+    // If the device has been added, check if it should inherit the parent's layout
+    if (deviceAdded && !parentUniqueId.empty())
+    {
+        FancyZonesDataInstance().CloneDeviceInfo(parentUniqueId, m_uniqueId);
+    }
+    CalculateZoneSet();
+}
+
+void ZoneWindow::CalculateZoneSet() noexcept
+{
+    const auto& fancyZonesData = FancyZonesDataInstance();
+    const auto deviceInfoData = fancyZonesData.FindDeviceInfo(m_uniqueId);
+
+    if (!deviceInfoData.has_value())
+    {
+        return;
+    }
+
+    const auto& activeZoneSet = deviceInfoData->activeZoneSet;
+
+    if (activeZoneSet.uuid.empty())
+    {
+        return;
+    }
+
+    GUID zoneSetId;
+    if (SUCCEEDED_LOG(CLSIDFromString(activeZoneSet.uuid.c_str(), &zoneSetId)))
+    {
+        int sensitivityRadius = deviceInfoData->sensitivityRadius;
+
+        auto zoneSet = MakeZoneSet(ZoneSetConfig(
+            zoneSetId,
+            activeZoneSet.type,
+            m_monitor,
+            sensitivityRadius,
+            m_host->GetOverlappingZonesAlgorithm()));
+
+        RECT workArea;
+        if (m_monitor)
+        {
+            MONITORINFO monitorInfo{};
+            monitorInfo.cbSize = sizeof(monitorInfo);
+            if (GetMonitorInfoW(m_monitor, &monitorInfo))
+            {
+                workArea = monitorInfo.rcWork;
+            }
+            else
+            {
+                return;
+            }
+        }
+        else
+        {
+            workArea = GetAllMonitorsCombinedRect<&MONITORINFO::rcWork>();
+        }
+
+        bool showSpacing = deviceInfoData->showSpacing;
+        int spacing = showSpacing ? deviceInfoData->spacing : 0;
+        int zoneCount = deviceInfoData->zoneCount;
+
+        zoneSet->CalculateZones(workArea, zoneCount, spacing);
+        UpdateActiveZoneSet(zoneSet.get());
+    }
+}
+
+void ZoneWindow::UpdateActiveZoneSet(_In_opt_ IZoneSet* zoneSet) noexcept
+{
+    m_activeZoneSet.copy_from(zoneSet);
+
+    if (m_activeZoneSet)
+    {
+        wil::unique_cotaskmem_string zoneSetId;
+        if (SUCCEEDED_LOG(StringFromCLSID(m_activeZoneSet->Id(), &zoneSetId)))
+        {
+            FancyZonesDataTypes::ZoneSetData data{
+                .uuid = zoneSetId.get(),
+                .type = m_activeZoneSet->LayoutType()
+            };
+            FancyZonesDataInstance().SetActiveZoneSet(m_uniqueId, data);
+        }
+    }
+}
+
+LRESULT ZoneWindow::WndProc(UINT message, WPARAM wparam, LPARAM lparam) noexcept
+{
+    switch (message)
+    {
+    case WM_NCDESTROY:
+    {
+        ::DefWindowProc(m_window, message, wparam, lparam);
+        SetWindowLongPtr(m_window, GWLP_USERDATA, 0);
+    }
+    break;
+
+    case WM_ERASEBKGND:
+        return 1;
+
+    default:
+    {
+        return DefWindowProc(m_window, message, wparam, lparam);
+    }
+    }
+    return 0;
+}
+
+std::vector<size_t> ZoneWindow::ZonesFromPoint(POINT pt) noexcept
+{
+    if (m_activeZoneSet)
+    {
+        return m_activeZoneSet->ZonesFromPoint(pt);
+    }
+    return {};
+}
+
+void ZoneWindow::SetAsTopmostWindow() noexcept
+{
+    if (!m_window)
+    {
+        return;
+    }
+
+    UINT flags = SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE;
+
+    HWND windowInsertAfter = m_windowMoveSize;
+    if (windowInsertAfter == nullptr)
+    {
+        windowInsertAfter = HWND_TOPMOST;
+    }
+
+    SetWindowPos(m_window, windowInsertAfter, 0, 0, 0, 0, flags);
+}
+
+#pragma endregion
+
+LRESULT CALLBACK ZoneWindow::s_WndProc(HWND window, UINT message, WPARAM wparam, LPARAM lparam) noexcept
+{
+    auto thisRef = reinterpret_cast<ZoneWindow*>(GetWindowLongPtr(window, GWLP_USERDATA));
+    if ((thisRef == nullptr) && (message == WM_CREATE))
+    {
+        auto createStruct = reinterpret_cast<LPCREATESTRUCT>(lparam);
+        thisRef = reinterpret_cast<ZoneWindow*>(createStruct->lpCreateParams);
+        SetWindowLongPtr(window, GWLP_USERDATA, reinterpret_cast<LONG_PTR>(thisRef));
+    }
+
+    return (thisRef != nullptr) ? thisRef->WndProc(message, wparam, lparam) :
+                                  DefWindowProc(window, message, wparam, lparam);
+}
+
+winrt::com_ptr<IZoneWindow> MakeZoneWindow(IZoneWindowHost* host, HINSTANCE hinstance, HMONITOR monitor, const std::wstring& uniqueId, const std::wstring& parentUniqueId) noexcept
+{
+    auto self = winrt::make_self<ZoneWindow>(hinstance);
+    if (self->Init(host, hinstance, monitor, uniqueId, parentUniqueId))
+    {
+        return self;
+    }
+
+    return nullptr;
+}

src/modules/fancyzones/FancyZonesLib/ZoneWindow.h

@@ -0,0 +1,121 @@
+#pragma once
+#include "FancyZones.h"
+#include "FancyZonesLib/ZoneSet.h"
+
+/**
+ * Class representing single work area, which is defined by monitor and virtual desktop.
+ */
+interface __declspec(uuid("{7F017528-8110-4FB3-BE41-F472969C2560}")) IZoneWindow : public IUnknown
+{
+    /**
+     * A window is being moved or resized. Track down window position and give zone layout
+     * hints if dragging functionality is enabled.
+     *
+     * @param   window      Handle of window being moved or resized.
+     */
+    IFACEMETHOD(MoveSizeEnter)(HWND window) = 0;
+
+    /**
+     * A window has changed location, shape, or size. Track down window position and give zone layout
+     * hints if dragging functionality is enabled.
+     *
+     * @param   ptScreen        Cursor coordinates.
+     * @param   dragEnabled     Boolean indicating is giving hints about active zone layout enabled.
+     *                          Hints are given while dragging window while holding SHIFT key.
+     * @param   selectManyZones When this parameter is true, the set of highlighted zones is computed
+     *                          by finding the minimum bounding rectangle of the zone(s) from which the
+     *                          user started dragging and the zone(s) above which the user is hovering
+     *                          at the moment this function is called. Otherwise, highlight only the zone(s)
+     *                          above which the user is currently hovering.
+     */
+    IFACEMETHOD(MoveSizeUpdate)(POINT const& ptScreen, bool dragEnabled, bool selectManyZones) = 0;
+    /**
+     * The movement or resizing of a window has finished. Assign window to the zone of it
+     * is dropped within zone borders.
+     *
+     * @param window   Handle of window being moved or resized.
+     * @param ptScreen Cursor coordinates where window is dropped.
+     */
+    IFACEMETHOD(MoveSizeEnd)(HWND window, POINT const& ptScreen) = 0;
+    /**
+     * Assign window to the zone based on zone index inside zone layout.
+     *
+     * @param   window Handle of window which should be assigned to zone.
+     * @param   index  Zone index within zone layout.
+     */
+    IFACEMETHOD_(void, MoveWindowIntoZoneByIndex)(HWND window, size_t index) = 0;
+    /**
+     * Assign window to the zones based on the set of zone indices inside zone layout.
+     *
+     * @param   window   Handle of window which should be assigned to zone.
+     * @param   indexSet The set of zone indices within zone layout.
+     */
+    IFACEMETHOD_(void, MoveWindowIntoZoneByIndexSet)(HWND window, const std::vector<size_t>& indexSet) = 0;
+    /**
+     * Assign window to the zone based on direction (using WIN + LEFT/RIGHT arrow), based on zone index numbers,
+     * not their on-screen position.
+     *
+     * @param   window Handle of window which should be assigned to zone.
+     * @param   vkCode Pressed arrow key.
+     * @param   cycle  Whether we should move window to the first zone if we reached last zone in layout.
+     *
+     * @returns Boolean which is always true if cycle argument is set, otherwise indicating if there is more
+     *          zones left in the zone layout in which window can move.
+     */
+    IFACEMETHOD_(bool, MoveWindowIntoZoneByDirectionAndIndex)(HWND window, DWORD vkCode, bool cycle) = 0;
+    /**
+     * Assign window to the zone based on direction (using WIN + LEFT/RIGHT/UP/DOWN arrow), based on
+     * their on-screen position.
+     *
+     * @param   window Handle of window which should be assigned to zone.
+     * @param   vkCode Pressed arrow key.
+     * @param   cycle  Whether we should move window to the first zone if we reached last zone in layout.
+     *
+     * @returns Boolean which is always true if cycle argument is set, otherwise indicating if there is more
+     *          zones left in the zone layout in which window can move.
+     */
+    IFACEMETHOD_(bool, MoveWindowIntoZoneByDirectionAndPosition)(HWND window, DWORD vkCode, bool cycle) = 0;
+    /**
+     * Extend or shrink the window to an adjacent zone based on direction (using CTRL+WIN+ALT + LEFT/RIGHT/UP/DOWN arrow), based on
+     * their on-screen position.
+     *
+     * @param   window Handle of window which should be assigned to zone.
+     * @param   vkCode Pressed arrow key.
+     *
+     * @returns Boolean indicating whether the window was rezoned. False could be returned when there are no more
+     *          zones available in the given direction.
+     */
+    IFACEMETHOD_(bool, ExtendWindowByDirectionAndPosition)(HWND window, DWORD vkCode) = 0;
+    /**
+     * Save information about zone in which window was assigned, when closing the window.
+     * Used once we open same window again to assign it to its previous zone.
+     *
+     * @param   window Window handle.
+     */
+    IFACEMETHOD_(void, SaveWindowProcessToZoneIndex)(HWND window) = 0;
+    /**
+     * @returns Unique work area identifier. Format: <device-id>_<resolution>_<virtual-desktop-id>
+     */
+    IFACEMETHOD_(std::wstring, UniqueId)() = 0;
+    /**
+     * @returns Active zone layout for this work area.
+     */
+    IFACEMETHOD_(IZoneSet*, ActiveZoneSet)() = 0;
+    IFACEMETHOD_(void, ShowZoneWindow)() = 0;
+    IFACEMETHOD_(void, HideZoneWindow)() = 0;
+    /**
+     * Update currently active zone layout for this work area.
+     */
+    IFACEMETHOD_(void, UpdateActiveZoneSet)() = 0;
+    /**
+     * Clear the selected zones when this ZoneWindow loses focus.
+     */
+    IFACEMETHOD_(void, ClearSelectedZones)() = 0;
+    /*
+     * Display the layout on the screen and then hide it.
+     */
+    IFACEMETHOD_(void, FlashZones)() = 0;
+};
+
+winrt::com_ptr<IZoneWindow> MakeZoneWindow(IZoneWindowHost* host, HINSTANCE hinstance, HMONITOR monitor,
+    const std::wstring& uniqueId, const std::wstring& parentUniqueId) noexcept;

src/modules/fancyzones/FancyZonesLib/ZoneWindowDrawing.cpp

@@ -0,0 +1,359 @@
+#include "pch.h"
+#include "ZoneWindowDrawing.h"
+#include "CallTracer.h"
+
+#include <algorithm>
+#include <map>
+#include <string>
+#include <vector>
+
+#include <common/logger/logger.h>
+
+namespace
+{
+    const int FadeInDurationMillis = 200;
+    const int FlashZonesDurationMillis = 700;
+}
+
+namespace NonLocalizable
+{
+    const wchar_t SegoeUiFont[] = L"Segoe ui";
+}
+
+float ZoneWindowDrawing::GetAnimationAlpha()
+{
+    // Lock is held by the caller
+
+    if (!m_animation)
+    {
+        return 0.f;
+    }
+
+    auto tNow = std::chrono::steady_clock().now();
+    auto millis = (tNow - m_animation->tStart).count() / 1e6f;
+
+    if (m_animation->autoHide && millis > FlashZonesDurationMillis)
+    {
+        return 0.f;
+    }
+
+    // Return a positive value to avoid hiding
+    return std::clamp(millis / FadeInDurationMillis, 0.001f, 1.f);
+}
+
+ID2D1Factory* ZoneWindowDrawing::GetD2DFactory()
+{
+    static auto pD2DFactory = [] {
+        ID2D1Factory* res = nullptr;
+        D2D1CreateFactory(D2D1_FACTORY_TYPE_MULTI_THREADED, &res);
+        return res;
+    }();
+    return pD2DFactory;
+}
+
+IDWriteFactory* ZoneWindowDrawing::GetWriteFactory()
+{
+    static auto pDWriteFactory = [] {
+        IUnknown* res = nullptr;
+        DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED, __uuidof(IDWriteFactory), &res);
+        return reinterpret_cast<IDWriteFactory*>(res);
+    }();
+    return pDWriteFactory;
+}
+
+D2D1_COLOR_F ZoneWindowDrawing::ConvertColor(COLORREF color)
+{
+    return D2D1::ColorF(GetRValue(color) / 255.f,
+                        GetGValue(color) / 255.f,
+                        GetBValue(color) / 255.f,
+                        1.f);
+}
+
+D2D1_RECT_F ZoneWindowDrawing::ConvertRect(RECT rect)
+{
+    return D2D1::RectF((float)rect.left + 0.5f, (float)rect.top + 0.5f, (float)rect.right - 0.5f, (float)rect.bottom - 0.5f);
+}
+
+ZoneWindowDrawing::ZoneWindowDrawing(HWND window)
+{
+    HRESULT hr;
+    m_window = window;
+    m_renderTarget = nullptr;
+    m_shouldRender = false;
+
+    // Obtain the size of the drawing area.
+    if (!GetClientRect(window, &m_clientRect))
+    {
+        Logger::error("couldn't initialize ZoneWindowDrawing: GetClientRect failed");
+        return;
+    }
+
+    // Create a Direct2D render target
+    // We should always use the DPI value of 96 since we're running in DPI aware mode
+    auto renderTargetProperties = D2D1::RenderTargetProperties(
+        D2D1_RENDER_TARGET_TYPE_DEFAULT,
+        D2D1::PixelFormat(DXGI_FORMAT_UNKNOWN, D2D1_ALPHA_MODE_PREMULTIPLIED),
+        96.f,
+        96.f);
+
+    auto renderTargetSize = D2D1::SizeU(m_clientRect.right - m_clientRect.left, m_clientRect.bottom - m_clientRect.top);
+    auto hwndRenderTargetProperties = D2D1::HwndRenderTargetProperties(window, renderTargetSize);
+
+    hr = GetD2DFactory()->CreateHwndRenderTarget(renderTargetProperties, hwndRenderTargetProperties, &m_renderTarget);
+
+    if (!SUCCEEDED(hr))
+    {
+        Logger::error("couldn't initialize ZoneWindowDrawing: CreateHwndRenderTarget failed with {}", hr);
+        return;
+    }
+
+    m_renderThread = std::thread([this]() { RenderLoop(); });
+}
+
+ZoneWindowDrawing::RenderResult ZoneWindowDrawing::Render()
+{
+    std::unique_lock lock(m_mutex);
+
+    if (!m_renderTarget)
+    {
+        return RenderResult::Failed;
+    }
+
+    float animationAlpha = GetAnimationAlpha();
+
+    if (animationAlpha <= 0.f)
+    {
+        return RenderResult::AnimationEnded;
+    }
+
+    m_renderTarget->BeginDraw();
+
+    // Draw backdrop
+    m_renderTarget->Clear(D2D1::ColorF(0.f, 0.f, 0.f, 0.f));
+
+    ID2D1SolidColorBrush* textBrush = nullptr;
+    IDWriteTextFormat* textFormat = nullptr;
+
+    m_renderTarget->CreateSolidColorBrush(D2D1::ColorF(D2D1::ColorF::Black, animationAlpha), &textBrush);
+    auto writeFactory = GetWriteFactory();
+
+    if (writeFactory)
+    {
+        writeFactory->CreateTextFormat(NonLocalizable::SegoeUiFont, nullptr, DWRITE_FONT_WEIGHT_NORMAL, DWRITE_FONT_STYLE_NORMAL, DWRITE_FONT_STRETCH_NORMAL, 80.f, L"en-US", &textFormat);
+    }
+
+    for (auto drawableRect : m_sceneRects)
+    {
+        ID2D1SolidColorBrush* borderBrush = nullptr;
+        ID2D1SolidColorBrush* fillBrush = nullptr;
+
+        // Need to copy the rect from m_sceneRects
+        drawableRect.borderColor.a *= animationAlpha;
+        drawableRect.fillColor.a *= animationAlpha;
+
+        m_renderTarget->CreateSolidColorBrush(drawableRect.borderColor, &borderBrush);
+        m_renderTarget->CreateSolidColorBrush(drawableRect.fillColor, &fillBrush);
+
+        if (fillBrush)
+        {
+            m_renderTarget->FillRectangle(drawableRect.rect, fillBrush);
+            fillBrush->Release();
+        }
+
+        if (borderBrush)
+        {
+            m_renderTarget->DrawRectangle(drawableRect.rect, borderBrush);
+            borderBrush->Release();
+        }
+
+        std::wstring idStr = std::to_wstring(drawableRect.id + 1);
+
+        if (textFormat && textBrush)
+        {
+            textFormat->SetTextAlignment(DWRITE_TEXT_ALIGNMENT_CENTER);
+            textFormat->SetParagraphAlignment(DWRITE_PARAGRAPH_ALIGNMENT_CENTER);
+            m_renderTarget->DrawTextW(idStr.c_str(), (UINT32)idStr.size(), textFormat, drawableRect.rect, textBrush);
+        }
+    }
+
+    if (textFormat)
+    {
+        textFormat->Release();
+    }
+
+    if (textBrush)
+    {
+        textBrush->Release();
+    }
+
+    // The lock must be released here, as EndDraw() will wait for vertical sync
+    lock.unlock();
+
+    m_renderTarget->EndDraw();
+    return RenderResult::Ok;
+}
+
+void ZoneWindowDrawing::RenderLoop()
+{
+    while (!m_abortThread)
+    {
+        {
+            // Wait here while rendering is disabled
+            std::unique_lock lock(m_mutex);
+            m_cv.wait(lock, [this]() { return (bool)m_shouldRender; });
+        }
+
+        auto result = Render();
+
+        if (result == RenderResult::AnimationEnded || result == RenderResult::Failed)
+        {
+            Hide();
+        }
+    }
+}
+
+void ZoneWindowDrawing::Hide()
+{
+    _TRACER_;
+    bool shouldHideWindow = true;
+    {
+        std::unique_lock lock(m_mutex);
+        m_animation.reset();
+        shouldHideWindow = m_shouldRender;
+        m_shouldRender = false;
+    }
+
+    if (shouldHideWindow)
+    {
+        ShowWindow(m_window, SW_HIDE);
+    }
+}
+
+void ZoneWindowDrawing::Show()
+{
+    _TRACER_;
+    bool shouldShowWindow = true;
+    {
+        std::unique_lock lock(m_mutex);
+        shouldShowWindow = !m_shouldRender;
+        m_shouldRender = true;
+
+        if (!m_animation)
+        {
+            m_animation.emplace(AnimationInfo{ .tStart = std::chrono::steady_clock().now(), .autoHide = false });
+        }
+        else if (m_animation->autoHide)
+        {
+            // Do not change the starting time of the animation, just reset autoHide
+            m_animation->autoHide = false;
+        }
+    }
+
+    if (shouldShowWindow)
+    {
+        ShowWindow(m_window, SW_SHOWNA);
+    }
+
+    m_cv.notify_all();
+}
+
+void ZoneWindowDrawing::Flash()
+{
+    _TRACER_;
+    bool shouldShowWindow = true;
+    {
+        std::unique_lock lock(m_mutex);
+        shouldShowWindow = !m_shouldRender;
+        m_shouldRender = true;
+
+        m_animation.emplace(AnimationInfo{ .tStart = std::chrono::steady_clock().now(), .autoHide = true });
+    }
+
+    if (shouldShowWindow)
+    {
+        ShowWindow(m_window, SW_SHOWNA);
+    }
+
+    m_cv.notify_all();
+}
+
+void ZoneWindowDrawing::DrawActiveZoneSet(const IZoneSet::ZonesMap& zones,
+                                          const std::vector<size_t>& highlightZones,
+                                          winrt::com_ptr<IZoneWindowHost> host)
+{
+    _TRACER_;
+    std::unique_lock lock(m_mutex);
+
+    m_sceneRects = {};
+
+    auto borderColor = ConvertColor(host->GetZoneBorderColor());
+    auto inactiveColor = ConvertColor(host->GetZoneColor());
+    auto highlightColor = ConvertColor(host->GetZoneHighlightColor());
+
+    inactiveColor.a = host->GetZoneHighlightOpacity() / 100.f;
+    highlightColor.a = host->GetZoneHighlightOpacity() / 100.f;
+
+    std::vector<bool> isHighlighted(zones.size() + 1, false);
+    for (size_t x : highlightZones)
+    {
+        isHighlighted[x] = true;
+    }
+
+    // First draw the inactive zones
+    for (const auto& [zoneId, zone] : zones)
+    {
+        if (!zone)
+        {
+            continue;
+        }
+
+        if (!isHighlighted[zoneId])
+        {
+            DrawableRect drawableRect{
+                .rect = ConvertRect(zone->GetZoneRect()),
+                .borderColor = borderColor,
+                .fillColor = inactiveColor,
+                .id = zone->Id()
+            };
+
+            m_sceneRects.push_back(drawableRect);
+        }
+    }
+
+    // Draw the active zones on top of the inactive zones
+    for (const auto& [zoneId, zone] : zones)
+    {
+        if (!zone)
+        {
+            continue;
+        }
+
+        if (isHighlighted[zoneId])
+        {
+            DrawableRect drawableRect{
+                .rect = ConvertRect(zone->GetZoneRect()),
+                .borderColor = borderColor,
+                .fillColor = highlightColor,
+                .id = zone->Id()
+            };
+
+            m_sceneRects.push_back(drawableRect);
+        }
+    }
+}
+
+ZoneWindowDrawing::~ZoneWindowDrawing()
+{
+    {
+        std::unique_lock lock(m_mutex);
+        m_abortThread = true;
+        m_shouldRender = true;
+    }
+    m_cv.notify_all();
+    m_renderThread.join();
+
+    if (m_renderTarget)
+    {
+        m_renderTarget->Release();
+    }
+}

src/modules/fancyzones/FancyZonesLib/ZoneWindowDrawing.h

@@ -0,0 +1,69 @@
+#pragma once
+
+#include <map>
+#include <vector>
+#include <wil\resource.h>
+#include <winrt/base.h>
+#include <d2d1.h>
+#include <dwrite.h>
+
+#include "util.h"
+#include "Zone.h"
+#include "ZoneSet.h"
+#include "FancyZones.h"
+
+class ZoneWindowDrawing
+{
+    struct DrawableRect
+    {
+        D2D1_RECT_F rect;
+        D2D1_COLOR_F borderColor;
+        D2D1_COLOR_F fillColor;
+        size_t id;
+    };
+
+    struct AnimationInfo
+    {
+        std::chrono::steady_clock::time_point tStart;
+        bool autoHide;
+    };
+
+    enum struct RenderResult
+    {
+        Ok,
+        AnimationEnded,
+        Failed,
+    };
+
+    HWND m_window = nullptr;
+    RECT m_clientRect{};
+    ID2D1HwndRenderTarget* m_renderTarget = nullptr;
+    std::optional<AnimationInfo> m_animation;
+
+    std::mutex m_mutex;
+    std::vector<DrawableRect> m_sceneRects;
+
+    float GetAnimationAlpha();
+    static ID2D1Factory* GetD2DFactory();
+    static IDWriteFactory* GetWriteFactory();
+    static D2D1_COLOR_F ConvertColor(COLORREF color);
+    static D2D1_RECT_F ConvertRect(RECT rect);
+    RenderResult Render();
+    void RenderLoop();
+
+    std::atomic<bool> m_shouldRender = false;
+    std::atomic<bool> m_abortThread = false;
+    std::condition_variable m_cv;
+    std::thread m_renderThread;
+
+public:
+
+    ~ZoneWindowDrawing();
+    ZoneWindowDrawing(HWND window);
+    void Hide();
+    void Show();
+    void Flash();
+    void DrawActiveZoneSet(const IZoneSet::ZonesMap& zones,
+                           const std::vector<size_t>& highlightZones,
+                           winrt::com_ptr<IZoneWindowHost> host);
+};

src/modules/fancyzones/FancyZonesLib/fancyzones.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"
+        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
+    END
+END

src/modules/fancyzones/FancyZonesLib/loc/cs/src/modules/fancyzones/lib/Resources.resx.lcl

@@ -0,0 +1,372 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LCX SchemaVersion="6.0" Name="S:\src\modules\fancyzones\FancyZonesLib\Resources.resx" PsrId="211" FileType="1" SrcCul="en-US" TgtCul="cs-CZ" xmlns="http://schemas.microsoft.com/locstudio/2006/6/lcx">
+  <OwnedComments>
+    <Cmt Name="Dev" />
+    <Cmt Name="LcxAdmin" />
+    <Cmt Name="Rccx" />
+  </OwnedComments>
+  <Settings Name="@SettingsPath@\default.lss" Type="Lss" />
+  <Item ItemId=";Resources.resx" ItemType="0" PsrId="211" Leaf="false">
+    <Disp Icon="Expand" Expand="true" Disp="true" LocTbl="false" />
+    <Item ItemId=";Strings" ItemType="0" PsrId="211" Leaf="false">
+      <Disp Icon="Str" Disp="true" LocTbl="false" />
+      <Item ItemId=";Cant_Drag_Elevated" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[We've detected an application running with administrator privileges. This will prevent certain interactions with these applications.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Zjistili jsme, že aplikace běží s oprávněními správce. To zabrání určitým interakcím s těmito aplikacemi.]]></Val>
+          </Tgt>
+          <Prev Cat="Text">
+            <Val><![CDATA[We've detected an application running with administrator privileges. This blocks some functionality in PowerToys. Visit our wiki page to learn more.]]></Val>
+          </Prev>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Cant_Drag_Elevated_Dialog_Dont_Show_Again" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Don't show again]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Příště už nezobrazovat]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Cant_Drag_Elevated_Learn_More" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Learn more]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Další informace]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[FancyZones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[FancyZones]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Data_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[FancyZones persisted data path not found. Please report the bug to]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Nepovedlo se najít cestu k trvalým datům nástroje FancyZones. Nahlaste prosím chybu:]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Editor_Launch_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[The FancyZones editor failed to start. Please report the bug to]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Nepovedlo se spustit editor nástroje FancyZones. Nahlaste prosím chybu:]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Settings_Load_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to load the FancyZones settings. Default settings will be used.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Nepovedlo se načíst nastavení nástroje FancyZones. Použijí se výchozí nastavení.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Settings_Save_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to save the FancyZones settings. Please retry again later, if the problem persists report the bug to]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Nepovedlo se uložit nastavení nástroje FancyZones. Zkuste to prosím znovu později. Pokud s tím budou dál problémy, nahlaste chybu:]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Keyboard_Listener_Error" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to install keyboard listener.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Nepovedlo se nainstalovat naslouchací proces klávesnice.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Powertoys_FancyZones" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[PowerToys - FancyZones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[PowerToys – FancyZones]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Create window layouts to help make multi-tasking easy]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Umožňuje vytvářet rozložení oken v zájmu snadnějšího multitaskingu.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_AppLastZone_MoveWindows" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move newly created windows to their last known zone]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Přesunout nově vytvořená okna do jejich poslední známé zóny]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_DisplayChange_MoveWindows" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Keep windows in their zones when the screen resolution changes]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Při změně rozlišení obrazovky ponechat okna v jejich zónách]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_FlashZonesOnQuickSwitch" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Flash zones when switching layout]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Při přepínání rozložení problikávat zóny]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Make_Dragged_Window_Transparent" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Make dragged window transparent]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Nastavit přetahované okno jako průhledné]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_MouseSwitch" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Use a non-primary mouse button to toggle zone activation]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[K přepnutí aktivace zóny používat neprimární tlačítko myši]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Move_Window_Across_Monitors" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move windows between zones across all monitors when snapping with (Win + Arrow)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Při přichycování pomocí klávesové zkratky Windows+šipka přesouvat okna mezi zónami na všech monitorech]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Move_Windows_Based_On_Position" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move windows based on their position when snapping with (Win + Arrow)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Při přichycování pomocí klávesové zkratky Windows+šipka přesouvat okna podle jejich pozice]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Open_Window_On_Active_Monitor" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move newly created windows to the current active monitor [EXPERIMENTAL]5D;]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Přesunout nově vytvořená okna na aktuálně aktivní monitor [experimentální]5D;]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Override_Snap_Hotkeys" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Override Windows Snap hotkeys (Win + Arrow) to move windows between zones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Přepsat klávesovou zkratku funkce Přichytit systému Windows (Windows+šipka) a přesouvat okna mezi zónami]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_QuickLayoutSwitch" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Enable quick layout switch]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Povolit přepínač rychlého rozložení]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_RestoreSize" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Restore the original size of windows when unsnapping]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Při uvolňování obnovit původní velikost oken]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ShiftDrag" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Hold Shift key to activate zones while dragging]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Aktivovat zóny při přetahování podržením klávesy Shift]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Show_Fancy_Zones_On_All_Monitors" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Show zones on all monitors while dragging a window]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Při přetahování okna zobrazit zóny na všech monitorech]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Span_Zones_Across_Monitors" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Allow zones to span across monitors (all monitors must have the same DPI scaling)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Povolit, aby zóny zasahovaly na více monitorů (všechny monitory musí mít stejné rozlišení DPI)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Use_CursorPos_Editor_StartupScreen" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Follow mouse cursor instead of focus when launching editor in a multi-screen environment]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Při spouštění editoru v prostředí s více obrazovkami sledovat ukazatel myši místo fokusu]]></Val>
+          </Tgt>
+          <Prev Cat="Text">
+            <Val><![CDATA[Follow mouse cursor instead of focus when launching editor in a multi screen environment]]></Val>
+          </Prev>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneColor" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone inactive color (Default #F5FCFF)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Barva neaktivní zóny (výchozí: #F5FCFF)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneHighlightColor" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone highlight color (Default #008CFF)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Barva zvýraznění zóny (výchozí: #008CFF)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneSetChange_FlashZones" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Flash zones when the active FancyZones layout changes]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Blikání zón při změně aktivního rozložení nástroje FancyZones]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneSetChange_MoveWindows" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[During zone layout changes, windows assigned to a zone will match new size/positions]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Během změn rozložení zón použít pro okna přiřazená zóně novou velikost a pozici]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Zone_Border_Color" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone border color (Default #FFFFFF)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Barva ohraničení zóny (výchozí: #FFFFFF)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Excluded_Apps_Description" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[To exclude an application from snapping to zones add its name here (one per line). Excluded apps will react to the Windows Snap regardless of all other settings.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Pokud chcete vyloučit aplikace z přichycování do zón, přidejte sem jejich názvy (jeden na každý řádek). Vyloučené aplikace budou bez ohledu na všechna ostatní nastavení reagovat jenom na příkaz Přichytit systému Windows.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Button" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Edit zones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Upravit zóny]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Description" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[To launch the zone editor, select the Edit zones button below or press the zone editor hotkey anytime]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Pokud chcete spustit editor zón, vyberte níže tlačítko Upravit zóny nebo kdykoliv stiskněte klávesovou zkratku editoru zón.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Hotkey_Label" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Configure the zone editor hotkey]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Konfigurovat klávesovou zkratku editoru zón]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Label" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone configuration]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Konfigurace zóny]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Settings_Highlight_Opacity" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone opacity (%)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Neprůhlednost zóny (%)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Span_Across_Zones_Warning" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[The 'Allow zones to span across monitors' option requires all monitors to have the same DPI scaling to work properly.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Pro správné fungování možnosti „Povolit, aby zóny zasahovaly na více monitorů“ je potřeba, aby všechny monitory měly stejné rozlišení DPI.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Window_Event_Listener_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to install Windows event listener.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Nepovedlo se nainstalovat naslouchací proces událostí systému Windows.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+    </Item>
+  </Item>
+</LCX>

src/modules/fancyzones/FancyZonesLib/loc/de/src/modules/fancyzones/lib/Resources.resx.lcl

@@ -0,0 +1,372 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LCX SchemaVersion="6.0" Name="S:\src\modules\fancyzones\FancyZonesLib\Resources.resx" PsrId="211" FileType="1" SrcCul="en-US" TgtCul="de-DE" xmlns="http://schemas.microsoft.com/locstudio/2006/6/lcx">
+  <OwnedComments>
+    <Cmt Name="Dev" />
+    <Cmt Name="LcxAdmin" />
+    <Cmt Name="Rccx" />
+  </OwnedComments>
+  <Settings Name="@SettingsPath@\default.lss" Type="Lss" />
+  <Item ItemId=";Resources.resx" ItemType="0" PsrId="211" Leaf="false">
+    <Disp Icon="Expand" Expand="true" Disp="true" LocTbl="false" />
+    <Item ItemId=";Strings" ItemType="0" PsrId="211" Leaf="false">
+      <Disp Icon="Str" Disp="true" LocTbl="false" />
+      <Item ItemId=";Cant_Drag_Elevated" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[We've detected an application running with administrator privileges. This will prevent certain interactions with these applications.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Es wurde eine Anwendung erkannt, die mit Administratorberechtigungen ausgeführt wird. Hierdurch werden bestimmte Interaktionen mit diesen Anwendungen verhindert.]]></Val>
+          </Tgt>
+          <Prev Cat="Text">
+            <Val><![CDATA[We've detected an application running with administrator privileges. This blocks some functionality in PowerToys. Visit our wiki page to learn more.]]></Val>
+          </Prev>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Cant_Drag_Elevated_Dialog_Dont_Show_Again" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Don't show again]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Nicht mehr anzeigen]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Cant_Drag_Elevated_Learn_More" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Learn more]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Weitere Informationen]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[FancyZones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[FancyZones]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Data_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[FancyZones persisted data path not found. Please report the bug to]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Der persistierte FancyZones-Datenpfad wurde nicht gefunden. Melden Sie den Fehler an]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Editor_Launch_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[The FancyZones editor failed to start. Please report the bug to]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Fehler beim Starten des FancyZones-Editors. Melden Sie den Fehler unter]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Settings_Load_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to load the FancyZones settings. Default settings will be used.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Fehler beim Laden der FancyZones-Einstellungen. Es werden die Standardeinstellungen verwendet.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Settings_Save_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to save the FancyZones settings. Please retry again later, if the problem persists report the bug to]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Fehler beim Speichern der FancyZones-Einstellungen. Versuchen Sie es später noch mal. Falls das Problem weiterhin besteht, melden Sie den Fehler an]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Keyboard_Listener_Error" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to install keyboard listener.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Fehler beim Installieren des Tastaturlisteners.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Powertoys_FancyZones" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[PowerToys - FancyZones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[PowerToys – FancyZones]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Create window layouts to help make multi-tasking easy]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Erstellen Sie Fensterlayouts für ein einfaches Multitasking.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_AppLastZone_MoveWindows" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move newly created windows to their last known zone]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Neu erstellte Fenster in ihre letzte bekannte Zone verschieben]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_DisplayChange_MoveWindows" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Keep windows in their zones when the screen resolution changes]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Fenster bei Änderung der Bildschirmauflösung in ihren Zonen beibehalten]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_FlashZonesOnQuickSwitch" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Flash zones when switching layout]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Aufblinken der Zonen bei Layoutwechsel]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Make_Dragged_Window_Transparent" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Make dragged window transparent]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Gezogene Fenster transparent anzeigen]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_MouseSwitch" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Use a non-primary mouse button to toggle zone activation]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Nicht primäre Maustaste zum Umschalten der Zonenaktivierung verwenden]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Move_Window_Across_Monitors" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move windows between zones across all monitors when snapping with (Win + Arrow)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Fenster beim Andocken mit (WINDOWS+Pfeiltaste) zwischen Zonen aller Monitore verschieben]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Move_Windows_Based_On_Position" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move windows based on their position when snapping with (Win + Arrow)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Fenster beim Andocken mit (WINDOWS+Pfeiltaste) basierend auf ihrer Position verschieben]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Open_Window_On_Active_Monitor" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move newly created windows to the current active monitor [EXPERIMENTAL]5D;]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Neu erstellte Fenster auf den zurzeit aktiven Monitor verschieben [EXPERIMENTELL]5D;]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Override_Snap_Hotkeys" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Override Windows Snap hotkeys (Win + Arrow) to move windows between zones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Zum Verschieben von Fenstern zwischen Zonen Windows Snap-Tastenkürzel (WINDOWS+Pfeiltaste) außer Kraft setzen]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_QuickLayoutSwitch" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Enable quick layout switch]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Schnellen Layoutwechsel aktivieren]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_RestoreSize" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Restore the original size of windows when unsnapping]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Beim Abdocken ursprüngliche Fenstergröße wiederherstellen]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ShiftDrag" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Hold Shift key to activate zones while dragging]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Zum Aktivieren von Zonen beim Ziehen Umschalttaste gedrückt halten]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Show_Fancy_Zones_On_All_Monitors" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Show zones on all monitors while dragging a window]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Beim Ziehen eines Fensters Zonen auf allen Monitoren anzeigen]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Span_Zones_Across_Monitors" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Allow zones to span across monitors (all monitors must have the same DPI scaling)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Monitorübergreifende Zonen erlauben (alle Monitore müssen dieselbe DPI-Skalierung verwenden)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Use_CursorPos_Editor_StartupScreen" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Follow mouse cursor instead of focus when launching editor in a multi-screen environment]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Beim Start des Editors in einer Umgebung mit mehreren Monitoren Mauszeiger statt Fokus folgen]]></Val>
+          </Tgt>
+          <Prev Cat="Text">
+            <Val><![CDATA[Follow mouse cursor instead of focus when launching editor in a multi screen environment]]></Val>
+          </Prev>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneColor" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone inactive color (Default #F5FCFF)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Farbe für inaktive Zonen (Standardwert: #F5FCFF)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneHighlightColor" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone highlight color (Default #008CFF)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Farbe für Zonenhervorhebung (Standardwert: #008CFF)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneSetChange_FlashZones" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Flash zones when the active FancyZones layout changes]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Bei Änderungen am aktiven FancyZones-Layout blinken die Zonen kurz auf.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneSetChange_MoveWindows" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[During zone layout changes, windows assigned to a zone will match new size/positions]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Bei Änderungen am Zonenlayout entsprechen die einer Zone zugewiesenen Fenster den neuen Größen/Positionen.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Zone_Border_Color" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone border color (Default #FFFFFF)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Farbe für Zonenrahmen (Standardwert: #FFFFFF)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Excluded_Apps_Description" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[To exclude an application from snapping to zones add its name here (one per line). Excluded apps will react to the Windows Snap regardless of all other settings.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Um eine Anwendung vom Andocken an Zonen auszuschließen, fügen Sie hier Ihren Namen ein (eine pro Zeile). Ausgeschlossene Apps reagieren unabhängig von allen weiteren Einstellungen auf Windows Snap.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Button" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Edit zones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Zonen bearbeiten]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Description" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[To launch the zone editor, select the Edit zones button below or press the zone editor hotkey anytime]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Um den Zonen-Editor zu starten, klicken Sie unten auf die Schaltfläche "Zonen bearbeiten", oder drücken Sie zu einem beliebigen Zeitpunkt das Tastenkürzel für den Zonen-Editor.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Hotkey_Label" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Configure the zone editor hotkey]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Tastenkürzel für Zonen-Editor konfigurieren]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Label" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone configuration]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Zonenkonfiguration]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Settings_Highlight_Opacity" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone opacity (%)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Zonendeckkraft (%)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Span_Across_Zones_Warning" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[The 'Allow zones to span across monitors' option requires all monitors to have the same DPI scaling to work properly.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Für eine ordnungsgemäße Funktion der Option "Monitorübergreifende Zonen erlauben" müssen alle Monitore die gleiche DPI-Skalierung verwenden.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Window_Event_Listener_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to install Windows event listener.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Fehler beim Installieren des Windows-Ereignislisteners.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+    </Item>
+  </Item>
+</LCX>

src/modules/fancyzones/FancyZonesLib/loc/es/src/modules/fancyzones/lib/Resources.resx.lcl

@@ -0,0 +1,372 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LCX SchemaVersion="6.0" Name="S:\src\modules\fancyzones\FancyZonesLib\Resources.resx" PsrId="211" FileType="1" SrcCul="en-US" TgtCul="es-ES" xmlns="http://schemas.microsoft.com/locstudio/2006/6/lcx">
+  <OwnedComments>
+    <Cmt Name="Dev" />
+    <Cmt Name="LcxAdmin" />
+    <Cmt Name="Rccx" />
+  </OwnedComments>
+  <Settings Name="@SettingsPath@\default.lss" Type="Lss" />
+  <Item ItemId=";Resources.resx" ItemType="0" PsrId="211" Leaf="false">
+    <Disp Icon="Expand" Expand="true" Disp="true" LocTbl="false" />
+    <Item ItemId=";Strings" ItemType="0" PsrId="211" Leaf="false">
+      <Disp Icon="Str" Disp="true" LocTbl="false" />
+      <Item ItemId=";Cant_Drag_Elevated" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[We've detected an application running with administrator privileges. This will prevent certain interactions with these applications.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Se ha detectado una aplicación que se ejecuta con privilegios de administrador. Esto impedirá algunas interacciones con estas aplicaciones.]]></Val>
+          </Tgt>
+          <Prev Cat="Text">
+            <Val><![CDATA[We've detected an application running with administrator privileges. This blocks some functionality in PowerToys. Visit our wiki page to learn more.]]></Val>
+          </Prev>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Cant_Drag_Elevated_Dialog_Dont_Show_Again" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Don't show again]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[No volver a mostrar]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Cant_Drag_Elevated_Learn_More" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Learn more]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Más información]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[FancyZones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[FancyZones]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Data_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[FancyZones persisted data path not found. Please report the bug to]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[No se encontró la ruta de acceso a los datos persistentes de FancyZones. Notifique el error a]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Editor_Launch_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[The FancyZones editor failed to start. Please report the bug to]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[No se pudo iniciar el editor de FancyZones. Notifique el error a]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Settings_Load_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to load the FancyZones settings. Default settings will be used.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[No se pudo cargar la configuración de FancyZones. Se usará la configuración predeterminada.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Settings_Save_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to save the FancyZones settings. Please retry again later, if the problem persists report the bug to]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[No se pudo guardar la configuración de FancyZones. Vuelva a intentarlo más tarde y, si el problema continúa, notifique el error a]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Keyboard_Listener_Error" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to install keyboard listener.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[No se pudo instalar el cliente de escucha del teclado.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Powertoys_FancyZones" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[PowerToys - FancyZones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[PowerToys: FancyZones]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Create window layouts to help make multi-tasking easy]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Permite crear diseños de ventana para facilitar la funcionalidad multitarea.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_AppLastZone_MoveWindows" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move newly created windows to their last known zone]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Permite mover las ventanas recién creadas a la última zona conocida.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_DisplayChange_MoveWindows" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Keep windows in their zones when the screen resolution changes]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Permite mantener las ventanas en sus zonas cuando cambia la resolución de pantalla.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_FlashZonesOnQuickSwitch" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Flash zones when switching layout]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Resaltar las zonas al cambiar de diseño]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Make_Dragged_Window_Transparent" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Make dragged window transparent]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Hacer transparente la ventana arrastrada]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_MouseSwitch" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Use a non-primary mouse button to toggle zone activation]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Permite usar un botón del mouse no principal para alternar la activación de la zona.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Move_Window_Across_Monitors" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move windows between zones across all monitors when snapping with (Win + Arrow)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Mover las ventanas entre zonas en todos los monitores al acoplarlas con el acceso directo Windows + flecha]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Move_Windows_Based_On_Position" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move windows based on their position when snapping with (Win + Arrow)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Mover las ventanas según su posición al acoplarlas con el acceso directo Windows + flecha]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Open_Window_On_Active_Monitor" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move newly created windows to the current active monitor [EXPERIMENTAL]5D;]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Mover las ventanas recién creadas al monitor activo actual [EXPERIMENTAL]5D;]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Override_Snap_Hotkeys" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Override Windows Snap hotkeys (Win + Arrow) to move windows between zones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Permite reemplazar las teclas de acceso rápido de la característica Acoplar de Windows (Win + flecha) para mover las ventanas entre zonas.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_QuickLayoutSwitch" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Enable quick layout switch]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Habilitar el modificador de diseño rápido]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_RestoreSize" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Restore the original size of windows when unsnapping]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Restaurar el tamaño original de las ventanas al desacoplarlas]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ShiftDrag" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Hold Shift key to activate zones while dragging]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Permite mantener presionada la tecla Mayús para activar las zonas al arrastrar.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Show_Fancy_Zones_On_All_Monitors" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Show zones on all monitors while dragging a window]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Mostrar zonas en todos los monitores al arrastrar una ventana]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Span_Zones_Across_Monitors" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Allow zones to span across monitors (all monitors must have the same DPI scaling)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Permitir que las zonas se expandan entre los monitores (todos los monitores deben tener el mismo ajuste de PPP)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Use_CursorPos_Editor_StartupScreen" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Follow mouse cursor instead of focus when launching editor in a multi-screen environment]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Permite seguir el cursor del mouse en lugar del foco al iniciar el editor en un entorno de varias pantallas.]]></Val>
+          </Tgt>
+          <Prev Cat="Text">
+            <Val><![CDATA[Follow mouse cursor instead of focus when launching editor in a multi screen environment]]></Val>
+          </Prev>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneColor" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone inactive color (Default #F5FCFF)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Color inactivo de la zona (valor predeterminado: #F5FCFF)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneHighlightColor" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone highlight color (Default #008CFF)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Color del resaltado de la zona (valor predeterminado: #008CFF)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneSetChange_FlashZones" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Flash zones when the active FancyZones layout changes]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Activa la intermitencia en las zonas cuando cambia el diseño activo de FancyZones.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneSetChange_MoveWindows" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[During zone layout changes, windows assigned to a zone will match new size/positions]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Durante los cambios en el diseño de la zona, las ventanas asignadas a una zona coincidirán con los nuevos tamaños o puestos.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Zone_Border_Color" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone border color (Default #FFFFFF)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Color del borde de la zona (valor predeterminado: #FFFFFF)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Excluded_Apps_Description" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[To exclude an application from snapping to zones add its name here (one per line). Excluded apps will react to the Windows Snap regardless of all other settings.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Para evitar que una aplicación se acople a las zonas, agregue su nombre aquí (uno por línea). Las aplicaciones excluidas reaccionarán a la característica Acoplar de Windows, independientemente del resto de configuraciones.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Button" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Edit zones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Editar zonas]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Description" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[To launch the zone editor, select the Edit zones button below or press the zone editor hotkey anytime]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Para iniciar el editor de zonas, seleccione el botón Editar zonas que aparece a continuación o presione la tecla de acceso rápido del editor de zonas en cualquier momento.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Hotkey_Label" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Configure the zone editor hotkey]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Configurar la tecla de acceso rápido del editor de zonas]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Label" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone configuration]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Configuración de la zona]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Settings_Highlight_Opacity" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone opacity (%)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Opacidad de la zona (%)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Span_Across_Zones_Warning" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[The 'Allow zones to span across monitors' option requires all monitors to have the same DPI scaling to work properly.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[La opción "Permitir que las zonas se expandan entre los monitores" requiere que todos los monitores tengan el mismo ajuste de PPP para funcionar correctamente.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Window_Event_Listener_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to install Windows event listener.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[No se pudo instalar la escucha de eventos de Windows.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+    </Item>
+  </Item>
+</LCX>

src/modules/fancyzones/FancyZonesLib/loc/fr/src/modules/fancyzones/lib/Resources.resx.lcl

@@ -0,0 +1,372 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LCX SchemaVersion="6.0" Name="S:\src\modules\fancyzones\FancyZonesLib\Resources.resx" PsrId="211" FileType="1" SrcCul="en-US" TgtCul="fr-FR" xmlns="http://schemas.microsoft.com/locstudio/2006/6/lcx">
+  <OwnedComments>
+    <Cmt Name="Dev" />
+    <Cmt Name="LcxAdmin" />
+    <Cmt Name="Rccx" />
+  </OwnedComments>
+  <Settings Name="@SettingsPath@\default.lss" Type="Lss" />
+  <Item ItemId=";Resources.resx" ItemType="0" PsrId="211" Leaf="false">
+    <Disp Icon="Expand" Expand="true" Disp="true" LocTbl="false" />
+    <Item ItemId=";Strings" ItemType="0" PsrId="211" Leaf="false">
+      <Disp Icon="Str" Disp="true" LocTbl="false" />
+      <Item ItemId=";Cant_Drag_Elevated" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[We've detected an application running with administrator privileges. This will prevent certain interactions with these applications.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Nous avons détecté une application exécutée avec des privilèges d’administrateur. Cela empêchera certaines interactions avec ces applications.]]></Val>
+          </Tgt>
+          <Prev Cat="Text">
+            <Val><![CDATA[We've detected an application running with administrator privileges. This blocks some functionality in PowerToys. Visit our wiki page to learn more.]]></Val>
+          </Prev>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Cant_Drag_Elevated_Dialog_Dont_Show_Again" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Don't show again]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Ne plus afficher]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Cant_Drag_Elevated_Learn_More" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Learn more]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[En savoir plus]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[FancyZones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[FancyZones]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Data_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[FancyZones persisted data path not found. Please report the bug to]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Chemin de données persistantes FancyZones introuvable. Signalez le bogue à]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Editor_Launch_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[The FancyZones editor failed to start. Please report the bug to]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Le démarrage de l'éditeur FancyZones a échoué. Signalez le bogue à]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Settings_Load_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to load the FancyZones settings. Default settings will be used.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Le chargement des paramètres FancyZones a échoué. Les paramètres par défaut sont utilisés.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Settings_Save_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to save the FancyZones settings. Please retry again later, if the problem persists report the bug to]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[L'enregistrement des paramètres FancyZones a échoué. Réessayez plus tard, si le problème persiste, signalez le bogue à]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Keyboard_Listener_Error" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to install keyboard listener.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[L'installation de l'écouteur de clavier a échoué.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Powertoys_FancyZones" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[PowerToys - FancyZones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[PowerToys - FancyZones]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Create window layouts to help make multi-tasking easy]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Créer des dispositions de fenêtre pour faciliter le multitâche]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_AppLastZone_MoveWindows" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move newly created windows to their last known zone]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Déplacer les fenêtres nouvellement créées vers leur dernière zone connue]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_DisplayChange_MoveWindows" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Keep windows in their zones when the screen resolution changes]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Conserver les fenêtres dans leurs zones quand la résolution d'écran change]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_FlashZonesOnQuickSwitch" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Flash zones when switching layout]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Flasher les zones pendant le changement de disposition]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Make_Dragged_Window_Transparent" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Make dragged window transparent]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Rendre transparente la fenêtre glissante]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_MouseSwitch" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Use a non-primary mouse button to toggle zone activation]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Utiliser un bouton de souris non principal pour activer/désactiver une zone]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Move_Window_Across_Monitors" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move windows between zones across all monitors when snapping with (Win + Arrow)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Déplacer les fenêtres entre les zones sur tous les moniteurs en cas d'alignement avec (Win+flèche)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Move_Windows_Based_On_Position" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move windows based on their position when snapping with (Win + Arrow)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Déplacer les fenêtres en fonction de leur position en cas d'alignement avec (Win+flèche)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Open_Window_On_Active_Monitor" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move newly created windows to the current active monitor [EXPERIMENTAL]5D;]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Déplacer les fenêtres nouvellement créées vers le moniteur actif actuel [EXPÉRIMENTAL]5D;]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Override_Snap_Hotkeys" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Override Windows Snap hotkeys (Win + Arrow) to move windows between zones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Remplacer les touches de raccourci Windows Snap (Win+flèche) pour déplacer les fenêtres entre les zones]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_QuickLayoutSwitch" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Enable quick layout switch]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Activer le changement de disposition rapide]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_RestoreSize" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Restore the original size of windows when unsnapping]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Restaurer la taille d'origine des fenêtres pendant le désalignement]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ShiftDrag" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Hold Shift key to activate zones while dragging]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Maintenir la touche Maj enfoncée pour activer les zones pendant le déplacement]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Show_Fancy_Zones_On_All_Monitors" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Show zones on all monitors while dragging a window]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Afficher les zones sur tous les moniteurs pendant le déplacement d'une fenêtre]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Span_Zones_Across_Monitors" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Allow zones to span across monitors (all monitors must have the same DPI scaling)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Autoriser les zones à s'étendre sur plusieurs moniteurs (tous les moniteurs doivent avoir la même mise à l'échelle PPP)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Use_CursorPos_Editor_StartupScreen" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Follow mouse cursor instead of focus when launching editor in a multi-screen environment]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Suivre le curseur de la souris au lieu du focus en cas de lancement de l'éditeur dans un environnement multi-écran]]></Val>
+          </Tgt>
+          <Prev Cat="Text">
+            <Val><![CDATA[Follow mouse cursor instead of focus when launching editor in a multi screen environment]]></Val>
+          </Prev>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneColor" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone inactive color (Default #F5FCFF)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Couleur d'inactivité de zone (par défaut #F5FCFF)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneHighlightColor" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone highlight color (Default #008CFF)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Couleur de surbrillance de zone (par défaut #008CFF)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneSetChange_FlashZones" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Flash zones when the active FancyZones layout changes]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Flasher les zones quand la disposition FancyZones active change]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneSetChange_MoveWindows" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[During zone layout changes, windows assigned to a zone will match new size/positions]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Quand la disposition d'une zone change, les fenêtres attribuées à la zone s'ajustent à la nouvelle taille/position]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Zone_Border_Color" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone border color (Default #FFFFFF)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Couleur de bordure de zone (par défaut #FFFFFF)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Excluded_Apps_Description" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[To exclude an application from snapping to zones add its name here (one per line). Excluded apps will react to the Windows Snap regardless of all other settings.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Pour empêcher une application de s'aligner sur les zones, ajoutez son nom ici (un par ligne). Les applications bloquées réagissent seulement à Windows Snap, indépendamment de tous les autres paramètres.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Button" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Edit zones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Modifier les zones]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Description" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[To launch the zone editor, select the Edit zones button below or press the zone editor hotkey anytime]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Pour lancer l'éditeur de zone, sélectionnez le bouton Modifier les zones ci-dessous ou appuyez sur le raccourci clavier de l'éditeur de zone à tout moment]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Hotkey_Label" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Configure the zone editor hotkey]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Configurer le raccourci clavier de l'éditeur de zone]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Label" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone configuration]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Configuration de zone]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Settings_Highlight_Opacity" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone opacity (%)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Opacité de zone (%)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Span_Across_Zones_Warning" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[The 'Allow zones to span across monitors' option requires all monitors to have the same DPI scaling to work properly.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[L'option « Autoriser les zones à s'étendre sur plusieurs moniteurs » nécessite que tous les moniteurs aient la même mise à l'échelle PPP pour fonctionner correctement.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Window_Event_Listener_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to install Windows event listener.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[L'installation de l'écouteur d'événements Windows a échoué.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+    </Item>
+  </Item>
+</LCX>

src/modules/fancyzones/FancyZonesLib/loc/hu/src/modules/fancyzones/lib/Resources.resx.lcl

@@ -0,0 +1,372 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LCX SchemaVersion="6.0" Name="S:\src\modules\fancyzones\FancyZonesLib\Resources.resx" PsrId="211" FileType="1" SrcCul="en-US" TgtCul="hu-HU" xmlns="http://schemas.microsoft.com/locstudio/2006/6/lcx">
+  <OwnedComments>
+    <Cmt Name="Dev" />
+    <Cmt Name="LcxAdmin" />
+    <Cmt Name="Rccx" />
+  </OwnedComments>
+  <Settings Name="@SettingsPath@\default.lss" Type="Lss" />
+  <Item ItemId=";Resources.resx" ItemType="0" PsrId="211" Leaf="false">
+    <Disp Icon="Expand" Expand="true" Disp="true" LocTbl="false" />
+    <Item ItemId=";Strings" ItemType="0" PsrId="211" Leaf="false">
+      <Disp Icon="Str" Disp="true" LocTbl="false" />
+      <Item ItemId=";Cant_Drag_Elevated" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[We've detected an application running with administrator privileges. This will prevent certain interactions with these applications.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Rendszergazdai jogosultságokkal futó alkalmazást észleltünk. Ez megakadályoz ezen alkalmazásokkal kapcsolatos bizonyos kezelési műveleteket.]]></Val>
+          </Tgt>
+          <Prev Cat="Text">
+            <Val><![CDATA[We've detected an application running with administrator privileges. This blocks some functionality in PowerToys. Visit our wiki page to learn more.]]></Val>
+          </Prev>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Cant_Drag_Elevated_Dialog_Dont_Show_Again" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Don't show again]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Ne jelenjen meg többé]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Cant_Drag_Elevated_Learn_More" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Learn more]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[További információ]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[FancyZones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[FancyZones]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Data_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[FancyZones persisted data path not found. Please report the bug to]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[A FancyZones megőrzött adatainak elérési útja nem található. Jelentse a hibát itt:]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Editor_Launch_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[The FancyZones editor failed to start. Please report the bug to]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[A FancyZones szerkesztőjét nem sikerült elindítani. Jelentse a hibát itt:]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Settings_Load_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to load the FancyZones settings. Default settings will be used.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Nem sikerült betölteni a FancyZones beállításait. Az alapértelmezett beállítások lesznek használva.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Settings_Save_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to save the FancyZones settings. Please retry again later, if the problem persists report the bug to]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Nem sikerült menteni a FancyZones beállításait. Próbálkozzon újra később. Ha a probléma továbbra is fennáll, jelentse a hibát itt:]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Keyboard_Listener_Error" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to install keyboard listener.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Nem sikerült telepíteni a billentyűzetfigyelőt.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Powertoys_FancyZones" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[PowerToys - FancyZones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[PowerToys – FancyZones]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Create window layouts to help make multi-tasking easy]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Ablakelrendezések létrehozása, amelyekkel megkönnyíthetők a párhuzamos műveletek]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_AppLastZone_MoveWindows" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move newly created windows to their last known zone]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Az újonnan létrehozott ablakok áthelyezése a legutóbbi ismert zónájukba]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_DisplayChange_MoveWindows" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Keep windows in their zones when the screen resolution changes]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Az ablakok zónáikban tartása a képernyőfelbontás módosításakor]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_FlashZonesOnQuickSwitch" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Flash zones when switching layout]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Zónák villogtatása az elrendezés váltásakor]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Make_Dragged_Window_Transparent" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Make dragged window transparent]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[A húzott ablak átlátszóvá tétele]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_MouseSwitch" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Use a non-primary mouse button to toggle zone activation]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Nem elsődleges egérgomb használata a zóna aktiválásának váltásához]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Move_Window_Across_Monitors" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move windows between zones across all monitors when snapping with (Win + Arrow)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Ablakok zónák közötti áthelyezése az összes képernyőn dokkoláskor (Win + nyílbillentyű)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Move_Windows_Based_On_Position" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move windows based on their position when snapping with (Win + Arrow)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Ablakok áthelyezése a pozíciójuk alapján dokkoláskor (Win + nyílbillentyű)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Open_Window_On_Active_Monitor" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move newly created windows to the current active monitor [EXPERIMENTAL]5D;]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Az újonnan létrehozott ablakok áthelyezése a jelenleg aktív képernyőre [KÍSÉRLETI]5D;]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Override_Snap_Hotkeys" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Override Windows Snap hotkeys (Win + Arrow) to move windows between zones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[A Windows dokkolási gyorsbillentyűinek (Win + nyílbillentyű) felülbírálása az ablakok zónák közötti áthelyezéséhez]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_QuickLayoutSwitch" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Enable quick layout switch]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Gyors elrendezésváltás engedélyezése]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_RestoreSize" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Restore the original size of windows when unsnapping]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Az ablakok eredeti méretének visszaállítása kidokkoláskor]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ShiftDrag" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Hold Shift key to activate zones while dragging]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[A Shift billentyű nyomva tartásával aktiválhatja a zónákat húzás közben]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Show_Fancy_Zones_On_All_Monitors" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Show zones on all monitors while dragging a window]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Zónák megjelenítése az összes képernyőn ablak húzása közben]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Span_Zones_Across_Monitors" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Allow zones to span across monitors (all monitors must have the same DPI scaling)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Zónák több képernyőre való kiterjedésének engedélyezése (minden képernyőnek azonos DPI-skálázással kell rendelkeznie)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Use_CursorPos_Editor_StartupScreen" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Follow mouse cursor instead of focus when launching editor in a multi-screen environment]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Az egérmutató követése a fókusz helyett a szerkesztő többképernyős környezetben való indításakor]]></Val>
+          </Tgt>
+          <Prev Cat="Text">
+            <Val><![CDATA[Follow mouse cursor instead of focus when launching editor in a multi screen environment]]></Val>
+          </Prev>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneColor" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone inactive color (Default #F5FCFF)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Zóna inaktív színe (alapértelmezés szerint #F5FCFF)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneHighlightColor" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone highlight color (Default #008CFF)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Zóna kiemelőszíne (alapértelmezés szerint #008CFF)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneSetChange_FlashZones" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Flash zones when the active FancyZones layout changes]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Zónák felvillantása, amikor a FancyZones aktív elrendezése megváltozik]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneSetChange_MoveWindows" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[During zone layout changes, windows assigned to a zone will match new size/positions]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[A zóna elrendezésének módosításakor az adott zónához rendelt ablakok illeszkedni fognak az új mérethez vagy pozícióhoz]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Zone_Border_Color" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone border color (Default #FFFFFF)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Zóna szegélyszíne (alapértelmezés szerint #FFFFFF)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Excluded_Apps_Description" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[To exclude an application from snapping to zones add its name here (one per line). Excluded apps will react to the Windows Snap regardless of all other settings.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Ha ki szeretne zárni egy alkalmazást a zónákhoz való dokkolásból, adja meg annak nevét itt (soronként egyet). A kizárt alkalmazások a többi beállítástól függetlenül reagálni fognak a Windows rendszerbeli dokkolásra.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Button" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Edit zones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Zónák szerkesztése]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Description" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[To launch the zone editor, select the Edit zones button below or press the zone editor hotkey anytime]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[A zónaszerkesztő elindításához válassza a lenti Zónák szerkesztése gombot, vagy nyomja meg bármikor a zónaszerkesztő gyorsbillentyűjét]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Hotkey_Label" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Configure the zone editor hotkey]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[A zónaszerkesztő gyorsbillentyűjének konfigurálása]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Label" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone configuration]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Zóna konfigurációja]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Settings_Highlight_Opacity" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone opacity (%)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Zóna átlátszatlansága (%)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Span_Across_Zones_Warning" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[The 'Allow zones to span across monitors' option requires all monitors to have the same DPI scaling to work properly.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[A „Zónák több képernyőre való kiterjedésének engedélyezése” beállítás megfelelő működéséhez minden képernyőnek ugyanolyan DPI-skálázással kell rendelkeznie.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Window_Event_Listener_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to install Windows event listener.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Nem sikerült telepíteni a Windows-eseményfigyelőt.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+    </Item>
+  </Item>
+</LCX>

src/modules/fancyzones/FancyZonesLib/loc/it/src/modules/fancyzones/lib/Resources.resx.lcl

@@ -0,0 +1,372 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LCX SchemaVersion="6.0" Name="S:\src\modules\fancyzones\FancyZonesLib\Resources.resx" PsrId="211" FileType="1" SrcCul="en-US" TgtCul="it-IT" xmlns="http://schemas.microsoft.com/locstudio/2006/6/lcx">
+  <OwnedComments>
+    <Cmt Name="Dev" />
+    <Cmt Name="LcxAdmin" />
+    <Cmt Name="Rccx" />
+  </OwnedComments>
+  <Settings Name="@SettingsPath@\default.lss" Type="Lss" />
+  <Item ItemId=";Resources.resx" ItemType="0" PsrId="211" Leaf="false">
+    <Disp Icon="Expand" Expand="true" Disp="true" LocTbl="false" />
+    <Item ItemId=";Strings" ItemType="0" PsrId="211" Leaf="false">
+      <Disp Icon="Str" Disp="true" LocTbl="false" />
+      <Item ItemId=";Cant_Drag_Elevated" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[We've detected an application running with administrator privileges. This will prevent certain interactions with these applications.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[È stata rilevata un'applicazione in esecuzione con privilegi di amministratore. In questo modo si evitano determinate interazioni con queste applicazioni.]]></Val>
+          </Tgt>
+          <Prev Cat="Text">
+            <Val><![CDATA[We've detected an application running with administrator privileges. This blocks some functionality in PowerToys. Visit our wiki page to learn more.]]></Val>
+          </Prev>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Cant_Drag_Elevated_Dialog_Dont_Show_Again" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Don't show again]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Non visualizzare più questo messaggio]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Cant_Drag_Elevated_Learn_More" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Learn more]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Altre informazioni]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[FancyZones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[FancyZones]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Data_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[FancyZones persisted data path not found. Please report the bug to]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Il percorso dei dati persistenti di FancyZones non è stato trovato. Segnalare il bug a]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Editor_Launch_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[The FancyZones editor failed to start. Please report the bug to]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[L'avvio dell'editor di FancyZones non è riuscito. Segnalare il bug a]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Settings_Load_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to load the FancyZones settings. Default settings will be used.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Non è stato possibile caricare le impostazioni di FancyZones. Verranno usate le impostazioni predefinite.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Settings_Save_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to save the FancyZones settings. Please retry again later, if the problem persists report the bug to]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Non è stato possibile salvare le impostazioni di FancyZones. Riprovare più tardi. Se il problema persiste, contattare il supporto tecnico.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Keyboard_Listener_Error" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to install keyboard listener.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Non è stato possibile installare il listener della tastiera.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Powertoys_FancyZones" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[PowerToys - FancyZones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[PowerToys - FancyZones]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Create window layouts to help make multi-tasking easy]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Crea layout di finestre per semplificare il multitasking]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_AppLastZone_MoveWindows" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move newly created windows to their last known zone]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Sposta le finestre appena create nell'ultima zona nota]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_DisplayChange_MoveWindows" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Keep windows in their zones when the screen resolution changes]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Mantieni le finestre nelle relative zone quando cambia la risoluzione dello schermo]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_FlashZonesOnQuickSwitch" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Flash zones when switching layout]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Scambia le zone quando si cambia layout]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Make_Dragged_Window_Transparent" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Make dragged window transparent]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Rendi trasparente la finestra trascinata]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_MouseSwitch" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Use a non-primary mouse button to toggle zone activation]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Usa un pulsante non principale del mouse per attivare/disattivare l'attivazione della zona]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Move_Window_Across_Monitors" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move windows between zones across all monitors when snapping with (Win + Arrow)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Sposta le finestre tra le zone in tutti i monitor all'affiancamento con il tasto WINDOWS + tasti di direzione]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Move_Windows_Based_On_Position" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move windows based on their position when snapping with (Win + Arrow)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Sposta le finestre in base alla relativa posizione all'affiancamento delle finestre con il tasto WINDOWS + tasti di direzione]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Open_Window_On_Active_Monitor" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move newly created windows to the current active monitor [EXPERIMENTAL]5D;]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Sposta le finestre appena create nel monitor attivo corrente [SPERIMENTALE]5D;]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Override_Snap_Hotkeys" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Override Windows Snap hotkeys (Win + Arrow) to move windows between zones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Ignora combinazioni di tasti di Affianca finestre di Windows (tasto WINDOWS + tasti di direzione) per spostare le finestre tra le zone]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_QuickLayoutSwitch" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Enable quick layout switch]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Abilita commutazione rapida layout]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_RestoreSize" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Restore the original size of windows when unsnapping]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Ripristina le dimensioni originali delle finestre all'annullamento dell'affiancamento delle finestre]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ShiftDrag" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Hold Shift key to activate zones while dragging]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Tenere premuto il tasto MAIUSC per attivare le zone durante il trascinamento]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Show_Fancy_Zones_On_All_Monitors" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Show zones on all monitors while dragging a window]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Mostra le zone su tutti i monitor durante il trascinamento di una finestra]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Span_Zones_Across_Monitors" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Allow zones to span across monitors (all monitors must have the same DPI scaling)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Consenti l'estensione delle zone tra i monitor (il ridimensionamento DPI deve essere uguale per tutti i monitor)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Use_CursorPos_Editor_StartupScreen" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Follow mouse cursor instead of focus when launching editor in a multi-screen environment]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Consente di seguire il puntatore del mouse anziché lo stato attivo all'avvio dell'editor in un ambiente multischermo]]></Val>
+          </Tgt>
+          <Prev Cat="Text">
+            <Val><![CDATA[Follow mouse cursor instead of focus when launching editor in a multi screen environment]]></Val>
+          </Prev>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneColor" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone inactive color (Default #F5FCFF)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Colore zona inattiva (valore predefinito: #F5FCFF)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneHighlightColor" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone highlight color (Default #008CFF)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Colore evidenziazione zona (valore predefinito: #008CFF)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneSetChange_FlashZones" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Flash zones when the active FancyZones layout changes]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Scambia le zone quando cambia il layout di FancyZones attivo]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneSetChange_MoveWindows" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[During zone layout changes, windows assigned to a zone will match new size/positions]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Durante le modifiche al layout delle zone, le finestre assegnate a una zona corrisponderanno a nuove dimensioni/posizioni]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Zone_Border_Color" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone border color (Default #FFFFFF)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Colore bordo zona (valore predefinito: #FFFFFF)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Excluded_Apps_Description" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[To exclude an application from snapping to zones add its name here (one per line). Excluded apps will react to the Windows Snap regardless of all other settings.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Per escludere un'applicazione dall'affiancamento delle finestre sulle zone, aggiungere qui il nome corrispondente (uno per riga). Le app escluse reagiranno alla funzionalità Affianca finestre di Windows indipendentemente da tutte le altre impostazioni.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Button" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Edit zones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Modifica zone]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Description" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[To launch the zone editor, select the Edit zones button below or press the zone editor hotkey anytime]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Per avviare l'editor di zone, fare clic sul pulsante Modifica zone sotto oppure premere la combinazione di tasti dell'editor di zone in qualsiasi momento]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Hotkey_Label" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Configure the zone editor hotkey]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Configura la combinazione di tasti dell'editor di zone]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Label" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone configuration]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Configurazione zona]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Settings_Highlight_Opacity" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone opacity (%)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Opacità zona (%)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Span_Across_Zones_Warning" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[The 'Allow zones to span across monitors' option requires all monitors to have the same DPI scaling to work properly.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Per il corretto funzionamento dell'opzione 'Consenti l'estensione delle zone tra i monitor', il ridimensionamento DPI deve essere uguale per tutti i monitor.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Window_Event_Listener_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to install Windows event listener.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Non è stato possibile installare il listener di eventi di Windows.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+    </Item>
+  </Item>
+</LCX>

src/modules/fancyzones/FancyZonesLib/loc/ja/src/modules/fancyzones/lib/Resources.resx.lcl

@@ -0,0 +1,372 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LCX SchemaVersion="6.0" Name="S:\src\modules\fancyzones\FancyZonesLib\Resources.resx" PsrId="211" FileType="1" SrcCul="en-US" TgtCul="ja-JP" xmlns="http://schemas.microsoft.com/locstudio/2006/6/lcx">
+  <OwnedComments>
+    <Cmt Name="Dev" />
+    <Cmt Name="LcxAdmin" />
+    <Cmt Name="Rccx" />
+  </OwnedComments>
+  <Settings Name="@SettingsPath@\default.lss" Type="Lss" />
+  <Item ItemId=";Resources.resx" ItemType="0" PsrId="211" Leaf="false">
+    <Disp Icon="Expand" Expand="true" Disp="true" LocTbl="false" />
+    <Item ItemId=";Strings" ItemType="0" PsrId="211" Leaf="false">
+      <Disp Icon="Str" Disp="true" LocTbl="false" />
+      <Item ItemId=";Cant_Drag_Elevated" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[We've detected an application running with administrator privileges. This will prevent certain interactions with these applications.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[管理特権で実行されているアプリケーションが検出されました。これにより、これらのアプリケーションとの特定の対話ができなくなります。]]></Val>
+          </Tgt>
+          <Prev Cat="Text">
+            <Val><![CDATA[We've detected an application running with administrator privileges. This blocks some functionality in PowerToys. Visit our wiki page to learn more.]]></Val>
+          </Prev>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Cant_Drag_Elevated_Dialog_Dont_Show_Again" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Don't show again]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[今後は表示しない]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Cant_Drag_Elevated_Learn_More" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Learn more]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[詳細情報]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[FancyZones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[FancyZones]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Data_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[FancyZones persisted data path not found. Please report the bug to]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[FancyZones の持続的なデータ パスが見つかりませんでした。このバグを次へご報告ください:]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Editor_Launch_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[The FancyZones editor failed to start. Please report the bug to]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[FancyZones エディターを開始できませんでした。このバグを次へご報告ください:]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Settings_Load_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to load the FancyZones settings. Default settings will be used.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[FancyZones の設定を読み込めませんでした。既定の設定が使用されます。]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Settings_Save_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to save the FancyZones settings. Please retry again later, if the problem persists report the bug to]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[FancyZones の設定を保存できませんでした。後でもう一度お試しください。問題が解決しない場合は、このバグを次へご報告ください:]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Keyboard_Listener_Error" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to install keyboard listener.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[キーボード リスナーをインストールできませんでした。]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Powertoys_FancyZones" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[PowerToys - FancyZones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[PowerToys - FancyZones]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Create window layouts to help make multi-tasking easy]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[簡単にマルチタスクを行えるように、ウィンドウ レイアウトを作成します]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_AppLastZone_MoveWindows" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move newly created windows to their last known zone]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[新しく作成されたウィンドウを最後の既知のゾーンに移動する]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_DisplayChange_MoveWindows" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Keep windows in their zones when the screen resolution changes]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[画面の解像度が変更されたときにウィンドウをゾーンに保持する]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_FlashZonesOnQuickSwitch" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Flash zones when switching layout]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[レイアウトを切り替えるときにゾーンを点滅させる]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Make_Dragged_Window_Transparent" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Make dragged window transparent]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[ドラッグしたウィンドウを透明にする]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_MouseSwitch" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Use a non-primary mouse button to toggle zone activation]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[プライマリ以外のマウス ボタンを使用してゾーンのアクティブ化を切り替える]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Move_Window_Across_Monitors" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move windows between zones across all monitors when snapping with (Win + Arrow)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Win+矢印キーを使用してスナップするときに、すべてのモニターのゾーン間でウィンドウを移動します]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Move_Windows_Based_On_Position" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move windows based on their position when snapping with (Win + Arrow)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Win+矢印キーを使用してスナップするときに、位置に応じてウィンドウを移動します]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Open_Window_On_Active_Monitor" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move newly created windows to the current active monitor [EXPERIMENTAL]5D;]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[新しく作成したウィンドウを現在アクティブなモニターに移動します [試験段階]5D;]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Override_Snap_Hotkeys" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Override Windows Snap hotkeys (Win + Arrow) to move windows between zones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Windows スナップのホットキー (Win+矢印キー) をオーバーライドして、ゾーン間でウィンドウを移動する]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_QuickLayoutSwitch" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Enable quick layout switch]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[クイック レイアウト スイッチを有効にする]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_RestoreSize" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Restore the original size of windows when unsnapping]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[スナップ解除する場合にウィンドウの元のサイズを復元する]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ShiftDrag" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Hold Shift key to activate zones while dragging]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[ドラッグ中に Shift キーを長押ししてゾーンをアクティブにする]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Show_Fancy_Zones_On_All_Monitors" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Show zones on all monitors while dragging a window]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[ウィンドウのドラッグ中にすべてのモニターでゾーンを表示する]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Span_Zones_Across_Monitors" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Allow zones to span across monitors (all monitors must have the same DPI scaling)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[ゾーンが複数のモニターにまたがることを許可する (すべてのモニターは同じ DPI スケールである必要があります)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Use_CursorPos_Editor_StartupScreen" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Follow mouse cursor instead of focus when launching editor in a multi-screen environment]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[マルチスクリーン環境でエディターを起動するときに、フォーカスする代わりにマウス カーソルの動きを追います]]></Val>
+          </Tgt>
+          <Prev Cat="Text">
+            <Val><![CDATA[Follow mouse cursor instead of focus when launching editor in a multi screen environment]]></Val>
+          </Prev>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneColor" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone inactive color (Default #F5FCFF)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[ゾーンの非アクティブの色 (既定値 #F5FCFF)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneHighlightColor" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone highlight color (Default #008CFF)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[ゾーンの強調表示の色 (既定値 #008CFF)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneSetChange_FlashZones" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Flash zones when the active FancyZones layout changes]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[アクティブな FancyZones レイアウトが変更されたときにゾーンを点滅させます]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneSetChange_MoveWindows" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[During zone layout changes, windows assigned to a zone will match new size/positions]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[ゾーン レイアウトの変更時に、ゾーンに割り当てられているウィンドウを新しいサイズまたは位置に合わせる]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Zone_Border_Color" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone border color (Default #FFFFFF)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[ゾーンの境界線の色 (既定値 #FFFFFF)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Excluded_Apps_Description" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[To exclude an application from snapping to zones add its name here (one per line). Excluded apps will react to the Windows Snap regardless of all other settings.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[アプリケーションをゾーンへのスナップから除外するには、その名前をここに追加します (1 行に 1 つ)。除外されたアプリは、他のすべての設定に関係なく、Windows のスナップに対応します。]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Button" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Edit zones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[ゾーンの編集]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Description" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[To launch the zone editor, select the Edit zones button below or press the zone editor hotkey anytime]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[ゾーン エディターを起動するには、下の [ゾーンの編集]5D; ボタンを選択するか、ゾーン エディターのホットキーを押します (常時可)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Hotkey_Label" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Configure the zone editor hotkey]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[ゾーン エディターのホットキーを構成]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Label" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone configuration]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[ゾーンを構成]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Settings_Highlight_Opacity" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone opacity (%)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[ゾーンの不透明度 (%)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Span_Across_Zones_Warning" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[The 'Allow zones to span across monitors' option requires all monitors to have the same DPI scaling to work properly.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[[ゾーンが複数のモニターにまたがることを許可します]5D; オプションが適切に機能するには、すべてのモニターが同じ DPI スケールである必要があります。]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Window_Event_Listener_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to install Windows event listener.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Windows イベント リスナーをインストールできませんでした。]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+    </Item>
+  </Item>
+</LCX>

src/modules/fancyzones/FancyZonesLib/loc/ko/src/modules/fancyzones/lib/Resources.resx.lcl

@@ -0,0 +1,372 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LCX SchemaVersion="6.0" Name="S:\src\modules\fancyzones\FancyZonesLib\Resources.resx" PsrId="211" FileType="1" SrcCul="en-US" TgtCul="ko-KR" xmlns="http://schemas.microsoft.com/locstudio/2006/6/lcx">
+  <OwnedComments>
+    <Cmt Name="Dev" />
+    <Cmt Name="LcxAdmin" />
+    <Cmt Name="Rccx" />
+  </OwnedComments>
+  <Settings Name="@SettingsPath@\default.lss" Type="Lss" />
+  <Item ItemId=";Resources.resx" ItemType="0" PsrId="211" Leaf="false">
+    <Disp Icon="Expand" Expand="true" Disp="true" LocTbl="false" />
+    <Item ItemId=";Strings" ItemType="0" PsrId="211" Leaf="false">
+      <Disp Icon="Str" Disp="true" LocTbl="false" />
+      <Item ItemId=";Cant_Drag_Elevated" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[We've detected an application running with administrator privileges. This will prevent certain interactions with these applications.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[관리자 권한으로 실행되는 응용 프로그램을 감지했습니다. 이를 통해 이러한 응용 프로그램과의 상호 작용을 방지할 수 있습니다.]]></Val>
+          </Tgt>
+          <Prev Cat="Text">
+            <Val><![CDATA[We've detected an application running with administrator privileges. This blocks some functionality in PowerToys. Visit our wiki page to learn more.]]></Val>
+          </Prev>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Cant_Drag_Elevated_Dialog_Dont_Show_Again" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Don't show again]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[다시 표시 안 함]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Cant_Drag_Elevated_Learn_More" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Learn more]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[자세한 정보]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[FancyZones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[FancyZones]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Data_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[FancyZones persisted data path not found. Please report the bug to]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[FancyZones 지속형 데이터 경로를 찾을 수 없습니다. 다음에 버그를 신고하세요.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Editor_Launch_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[The FancyZones editor failed to start. Please report the bug to]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[FancyZones 편집기를 시작하지 못했습니다. 다음에 버그를 신고하세요.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Settings_Load_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to load the FancyZones settings. Default settings will be used.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[FancyZones 설정을 로드하지 못했습니다. 기본 설정이 사용됩니다.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Settings_Save_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to save the FancyZones settings. Please retry again later, if the problem persists report the bug to]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[FancyZones 설정을 저장하지 못했습니다. 나중에 다시 시도하세요. 문제가 계속되면 다음에 버그를 신고하세요.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Keyboard_Listener_Error" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to install keyboard listener.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[키보드 수신기를 설치하지 못했습니다.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Powertoys_FancyZones" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[PowerToys - FancyZones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[PowerToys - FancyZones]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Create window layouts to help make multi-tasking easy]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[멀티태스킹을 쉽게 처리할 수 있도록 창 레이아웃 만들기]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_AppLastZone_MoveWindows" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move newly created windows to their last known zone]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[새로 만든 창을 마지막으로 알려진 영역으로 이동]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_DisplayChange_MoveWindows" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Keep windows in their zones when the screen resolution changes]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[화면 해상도가 변경될 때 영역의 창 유지]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_FlashZonesOnQuickSwitch" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Flash zones when switching layout]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[레이아웃 전환 시 영역 플래시]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Make_Dragged_Window_Transparent" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Make dragged window transparent]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[끌어온 창을 투명하게 만들기]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_MouseSwitch" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Use a non-primary mouse button to toggle zone activation]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[비기본 마우스 단추를 사용하여 영역 활성화 전환]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Move_Window_Across_Monitors" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move windows between zones across all monitors when snapping with (Win + Arrow)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[맞출 때 모든 모니터의 영역 간 창 이동(Win+화살표)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Move_Windows_Based_On_Position" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move windows based on their position when snapping with (Win + Arrow)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[맞출 때 위치를 기준으로 창 이동(Win+화살표)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Open_Window_On_Active_Monitor" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move newly created windows to the current active monitor [EXPERIMENTAL]5D;]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[새로 만든 창을 현재 활성 모니터로 이동[실험적]5D;]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Override_Snap_Hotkeys" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Override Windows Snap hotkeys (Win + Arrow) to move windows between zones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Windows 맞추기 핫키(Win+화살표)를 재정의하여 영역 간 창 이동]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_QuickLayoutSwitch" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Enable quick layout switch]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[빠른 레이아웃 전환 사용]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_RestoreSize" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Restore the original size of windows when unsnapping]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[맞추기를 해제할 때 창의 원래 크기 복원]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ShiftDrag" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Hold Shift key to activate zones while dragging]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Shift 키를 누른 채로 끌어와서 영역 활성화]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Show_Fancy_Zones_On_All_Monitors" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Show zones on all monitors while dragging a window]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[창을 끄는 동안 모든 모니터에 영역 표시]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Span_Zones_Across_Monitors" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Allow zones to span across monitors (all monitors must have the same DPI scaling)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[영역이 모니터 간에 확장되도록 허용(모든 모니터의 DPI 조정이 동일해야 함)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Use_CursorPos_Editor_StartupScreen" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Follow mouse cursor instead of focus when launching editor in a multi-screen environment]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[멀티스크린 환경에서 편집기를 시작할 때 포커스 대신 마우스 커서를 따름]]></Val>
+          </Tgt>
+          <Prev Cat="Text">
+            <Val><![CDATA[Follow mouse cursor instead of focus when launching editor in a multi screen environment]]></Val>
+          </Prev>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneColor" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone inactive color (Default #F5FCFF)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[영역 비활성 색(기본값 #F5FCFF)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneHighlightColor" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone highlight color (Default #008CFF)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[영역 강조 색(기본값 #008CFF)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneSetChange_FlashZones" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Flash zones when the active FancyZones layout changes]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[활성 FancyZones 레이아웃 변경 시의 영역 플래시]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneSetChange_MoveWindows" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[During zone layout changes, windows assigned to a zone will match new size/positions]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[영역 레이아웃 변경 시, 영역에 할당되어 있던 창을 새 크기/위치에 맞게 변경]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Zone_Border_Color" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone border color (Default #FFFFFF)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[영역 테두리 색(기본값 #FFFFFF)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Excluded_Apps_Description" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[To exclude an application from snapping to zones add its name here (one per line). Excluded apps will react to the Windows Snap regardless of all other settings.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[영역에 맞추기에서 애플리케이션을 제외하려면 여기에 해당 이름을 추가하세요(줄마다 하나씩). 제외된 앱은 다른 모든 설정과 관계없이 Windows 맞추기에 반응합니다.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Button" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Edit zones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[영역 편집]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Description" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[To launch the zone editor, select the Edit zones button below or press the zone editor hotkey anytime]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[영역 편집기를 시작하려면 언제든지 아래의 [영역 편집]5D; 단추를 선택하거나 영역 편집기 핫키를 누르세요.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Hotkey_Label" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Configure the zone editor hotkey]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[영역 편집기 핫키 구성]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Label" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone configuration]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[영역 구성]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Settings_Highlight_Opacity" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone opacity (%)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[영역 불투명도(%)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Span_Across_Zones_Warning" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[The 'Allow zones to span across monitors' option requires all monitors to have the same DPI scaling to work properly.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA['영역이 모니터 간에 확장되도록 허용' 옵션이 제대로 작동하려면 모든 모니터의 DPI 조정이 동일해야 합니다.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Window_Event_Listener_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to install Windows event listener.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Windows 이벤트 수신기를 설치하지 못했습니다.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+    </Item>
+  </Item>
+</LCX>

src/modules/fancyzones/FancyZonesLib/loc/nl/src/modules/fancyzones/lib/Resources.resx.lcl

@@ -0,0 +1,372 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LCX SchemaVersion="6.0" Name="S:\src\modules\fancyzones\FancyZonesLib\Resources.resx" PsrId="211" FileType="1" SrcCul="en-US" TgtCul="nl-NL" xmlns="http://schemas.microsoft.com/locstudio/2006/6/lcx">
+  <OwnedComments>
+    <Cmt Name="Dev" />
+    <Cmt Name="LcxAdmin" />
+    <Cmt Name="Rccx" />
+  </OwnedComments>
+  <Settings Name="@SettingsPath@\default.lss" Type="Lss" />
+  <Item ItemId=";Resources.resx" ItemType="0" PsrId="211" Leaf="false">
+    <Disp Icon="Expand" Expand="true" Disp="true" LocTbl="false" />
+    <Item ItemId=";Strings" ItemType="0" PsrId="211" Leaf="false">
+      <Disp Icon="Str" Disp="true" LocTbl="false" />
+      <Item ItemId=";Cant_Drag_Elevated" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[We've detected an application running with administrator privileges. This will prevent certain interactions with these applications.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[We hebben een toepassing gevonden die wordt uitgevoerd met beheerdersbevoegdheden. Hierdoor worden bepaalde interacties met deze toepassingen voorkomen.]]></Val>
+          </Tgt>
+          <Prev Cat="Text">
+            <Val><![CDATA[We've detected an application running with administrator privileges. This blocks some functionality in PowerToys. Visit our wiki page to learn more.]]></Val>
+          </Prev>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Cant_Drag_Elevated_Dialog_Dont_Show_Again" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Don't show again]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Niet opnieuw weergeven]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Cant_Drag_Elevated_Learn_More" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Learn more]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Meer informatie]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[FancyZones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[FancyZones]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Data_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[FancyZones persisted data path not found. Please report the bug to]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Persistent gegevenspad van FancyZones is niet gevonden. Meld de fout bij]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Editor_Launch_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[The FancyZones editor failed to start. Please report the bug to]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[De FancyZones-editor kan niet worden gestart. Meld de fout bij]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Settings_Load_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to load the FancyZones settings. Default settings will be used.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Kan de FancyZones-instellingen niet laden. De standaardinstellingen worden gebruikt.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Settings_Save_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to save the FancyZones settings. Please retry again later, if the problem persists report the bug to]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Kan de FancyZones-instellingen niet opslaan. Probeer het later opnieuw. Als het probleem zich blijft voordoen, meldt u de bug bij]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Keyboard_Listener_Error" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to install keyboard listener.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Kan de toetsenbord-listener niet installeren.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Powertoys_FancyZones" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[PowerToys - FancyZones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[PowerToys - FancyZones]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Create window layouts to help make multi-tasking easy]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Vensterindelingen maken om multitasking eenvoudig te maken]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_AppLastZone_MoveWindows" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move newly created windows to their last known zone]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Nieuw gemaakte vensters naar hun laatst bekende zone verplaatsen]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_DisplayChange_MoveWindows" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Keep windows in their zones when the screen resolution changes]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Vensters in hun zones houden wanneer de beeldschermresolutie wordt gewijzigd]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_FlashZonesOnQuickSwitch" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Flash zones when switching layout]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Laat zones knipperen bij overschakelen naar een andere indeling]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Make_Dragged_Window_Transparent" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Make dragged window transparent]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Versleept venster doorzichtig maken]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_MouseSwitch" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Use a non-primary mouse button to toggle zone activation]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Een niet-primaire muisknop gebruiken om zoneactivering in of uit te schakelen]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Move_Window_Across_Monitors" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move windows between zones across all monitors when snapping with (Win + Arrow)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Vensters verplaatsen tussen zones over alle beeldschermen wanneer deze worden uitgelijnd met (Win + pijl)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Move_Windows_Based_On_Position" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move windows based on their position when snapping with (Win + Arrow)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Vensters verplaatsen op basis van hun positie bij het uitlijnen met (Win + pijl)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Open_Window_On_Active_Monitor" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move newly created windows to the current active monitor [EXPERIMENTAL]5D;]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Nieuw gemaakte vensters naar het huidige actieve beeldscherm verplaatsen [EXPERIMENTEEL]5D;]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Override_Snap_Hotkeys" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Override Windows Snap hotkeys (Win + Arrow) to move windows between zones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Windows Snap-sneltoetsen (Win + pijl) overschrijven om vensters tussen zones te verplaatsen]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_QuickLayoutSwitch" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Enable quick layout switch]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Snel overschakelen naar andere indeling inschakelen]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_RestoreSize" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Restore the original size of windows when unsnapping]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Het oorspronkelijke formaat van vensters herstellen wanneer de uitlijning ongedaan wordt gemaakt]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ShiftDrag" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Hold Shift key to activate zones while dragging]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[De Shift-toets vasthouden om zones te activeren tijdens het slepen]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Show_Fancy_Zones_On_All_Monitors" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Show zones on all monitors while dragging a window]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Zones op alle beeldschermen weergeven tijdens het slepen van een venster]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Span_Zones_Across_Monitors" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Allow zones to span across monitors (all monitors must have the same DPI scaling)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Zones over meerdere schermen toestaan (alle schermen moeten dezelfde DPI-schaal hebben)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Use_CursorPos_Editor_StartupScreen" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Follow mouse cursor instead of focus when launching editor in a multi-screen environment]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[De muiscursor volgen in plaats van de focusmodus gebruiken wanneer de editor wordt gestart in een omgeving met meerdere beeldschermen]]></Val>
+          </Tgt>
+          <Prev Cat="Text">
+            <Val><![CDATA[Follow mouse cursor instead of focus when launching editor in a multi screen environment]]></Val>
+          </Prev>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneColor" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone inactive color (Default #F5FCFF)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Kleur van inactieve zone (standaard #F5FCFF)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneHighlightColor" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone highlight color (Default #008CFF)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Markeringskleur van zone (standaard #008CFF)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneSetChange_FlashZones" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Flash zones when the active FancyZones layout changes]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Laat zones knipperen wanneer de indeling van de actieve FancyZones wordt gewijzigd]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneSetChange_MoveWindows" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[During zone layout changes, windows assigned to a zone will match new size/positions]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Tijdens wijzigingen in de zone-indeling, worden vensters die aan een zone zijn toegewezen, afgestemd op de nieuwe grootte/posities]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Zone_Border_Color" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone border color (Default #FFFFFF)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Randkleur van zone (standaard #FFFFFF)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Excluded_Apps_Description" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[To exclude an application from snapping to zones add its name here (one per line). Excluded apps will react to the Windows Snap regardless of all other settings.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Als u wilt voorkomen dat een toepassing op zones wordt uitgelijnd, voegt u hier de naam (één per regel) toe. Uitgesloten apps reageren op de Windows-uitlijning, ongeacht alle andere instellingen.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Button" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Edit zones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Zones bewerken]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Description" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[To launch the zone editor, select the Edit zones button below or press the zone editor hotkey anytime]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Als u de zone-editor wilt starten, selecteert u de onderstaande knop Zones bewerken of drukt u op elk willekeurig moment op de sneltoets Zone-editor]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Hotkey_Label" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Configure the zone editor hotkey]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[De sneltoets voor de zone-editor configureren]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Label" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone configuration]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Zoneconfiguratie]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Settings_Highlight_Opacity" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone opacity (%)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Zonedekking (%)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Span_Across_Zones_Warning" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[The 'Allow zones to span across monitors' option requires all monitors to have the same DPI scaling to work properly.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Voor de optie Zones toestaan over meerdere beeldschermen moeten alle beeldschermen dezelfde DPI-schaalbaarheid hebben om correct te werken.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Window_Event_Listener_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to install Windows event listener.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Kan de Windows-gebeurtenislistener niet installeren.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+    </Item>
+  </Item>
+</LCX>

src/modules/fancyzones/FancyZonesLib/loc/pl/src/modules/fancyzones/lib/Resources.resx.lcl

@@ -0,0 +1,372 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LCX SchemaVersion="6.0" Name="S:\src\modules\fancyzones\FancyZonesLib\Resources.resx" PsrId="211" FileType="1" SrcCul="en-US" TgtCul="pl-PL" xmlns="http://schemas.microsoft.com/locstudio/2006/6/lcx">
+  <OwnedComments>
+    <Cmt Name="Dev" />
+    <Cmt Name="LcxAdmin" />
+    <Cmt Name="Rccx" />
+  </OwnedComments>
+  <Settings Name="@SettingsPath@\default.lss" Type="Lss" />
+  <Item ItemId=";Resources.resx" ItemType="0" PsrId="211" Leaf="false">
+    <Disp Icon="Expand" Expand="true" Disp="true" LocTbl="false" />
+    <Item ItemId=";Strings" ItemType="0" PsrId="211" Leaf="false">
+      <Disp Icon="Str" Disp="true" LocTbl="false" />
+      <Item ItemId=";Cant_Drag_Elevated" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[We've detected an application running with administrator privileges. This will prevent certain interactions with these applications.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Wykryliśmy aplikację działającą z uprawnieniami administratora. Uniemożliwi to pewne interakcje z tymi aplikacjami.]]></Val>
+          </Tgt>
+          <Prev Cat="Text">
+            <Val><![CDATA[We've detected an application running with administrator privileges. This blocks some functionality in PowerToys. Visit our wiki page to learn more.]]></Val>
+          </Prev>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Cant_Drag_Elevated_Dialog_Dont_Show_Again" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Don't show again]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Nie pokazuj ponownie]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Cant_Drag_Elevated_Learn_More" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Learn more]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Dowiedz się więcej]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[FancyZones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[FancyZones]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Data_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[FancyZones persisted data path not found. Please report the bug to]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Nie znaleziono ścieżki utrwalonych danych narzędzia FancyZones. Zgłoś usterkę do]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Editor_Launch_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[The FancyZones editor failed to start. Please report the bug to]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Nie można uruchomić edytora FancyZones. Zgłoś usterkę do]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Settings_Load_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to load the FancyZones settings. Default settings will be used.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Nie można załadować ustawień narzędzia FancyZones. Zostaną użyte ustawienia domyślne.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Settings_Save_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to save the FancyZones settings. Please retry again later, if the problem persists report the bug to]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Nie można zapisać ustawień narzędzia FancyZones. Spróbuj ponownie później, a jeśli problem będzie się powtarzać, zgłoś usterkę do]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Keyboard_Listener_Error" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to install keyboard listener.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Nie można zainstalować odbiornika klawiatury.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Powertoys_FancyZones" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[PowerToys - FancyZones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[PowerToys — FancyZones]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Create window layouts to help make multi-tasking easy]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Utwórz układy okien, aby ułatwić pracę wielozadaniową]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_AppLastZone_MoveWindows" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move newly created windows to their last known zone]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Przenieś nowo utworzone okna do ich ostatniej znanej strefy]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_DisplayChange_MoveWindows" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Keep windows in their zones when the screen resolution changes]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Utrzymuj okna w ich strefach, gdy zmienia się rozdzielczość ekranu]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_FlashZonesOnQuickSwitch" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Flash zones when switching layout]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Przełącz strefy podczas przełączania układu]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Make_Dragged_Window_Transparent" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Make dragged window transparent]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Ustaw przeciągane okno jako przezroczyste]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_MouseSwitch" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Use a non-primary mouse button to toggle zone activation]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Aktywuj strefy przyciskiem myszy innym niż podstawowy]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Move_Window_Across_Monitors" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move windows between zones across all monitors when snapping with (Win + Arrow)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Przenoszenie okien między strefami na wszystkich monitorach podczas przyciągania przy użyciu klawiszy (Win + strzałka)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Move_Windows_Based_On_Position" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move windows based on their position when snapping with (Win + Arrow)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Przenoszenie okien na podstawie ich położenia podczas przyciągania za pomocą klawiszy (Win + strzałka)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Open_Window_On_Active_Monitor" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move newly created windows to the current active monitor [EXPERIMENTAL]5D;]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Przenoszenie nowo utworzonych okien na bieżący aktywny monitor [EKSPERYMENTALNE]5D;]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Override_Snap_Hotkeys" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Override Windows Snap hotkeys (Win + Arrow) to move windows between zones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Przesłoń klawisze dostępu funkcji przyciągania systemu Windows (Win + strzałka), aby przenosić okna między strefami]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_QuickLayoutSwitch" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Enable quick layout switch]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Włącz szybkie przełączanie układu]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_RestoreSize" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Restore the original size of windows when unsnapping]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Przywróć oryginalny rozmiar okien po odciągnięciu]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ShiftDrag" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Hold Shift key to activate zones while dragging]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Przytrzymaj klawisz Shift, aby uaktywnić strefy podczas przeciągania]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Show_Fancy_Zones_On_All_Monitors" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Show zones on all monitors while dragging a window]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Pokaż strefy na wszystkich monitorach podczas przeciągania okna]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Span_Zones_Across_Monitors" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Allow zones to span across monitors (all monitors must have the same DPI scaling)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Zezwalaj na rozciąganie stref między monitorami (wszystkie monitory muszą mieć to samo skalowanie DPI)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Use_CursorPos_Editor_StartupScreen" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Follow mouse cursor instead of focus when launching editor in a multi-screen environment]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Podążaj za kursorem myszy zamiast fokusu podczas uruchamiania edytora w środowisku wieloekranowym]]></Val>
+          </Tgt>
+          <Prev Cat="Text">
+            <Val><![CDATA[Follow mouse cursor instead of focus when launching editor in a multi screen environment]]></Val>
+          </Prev>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneColor" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone inactive color (Default #F5FCFF)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Kolor nieaktywny strefy (domyślnie #F5FCFF)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneHighlightColor" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone highlight color (Default #008CFF)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Kolor wyróżnienia strefy (domyślnie #008CFF)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneSetChange_FlashZones" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Flash zones when the active FancyZones layout changes]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Przełączaj strefy w przypadku zmiany aktywnego układu narzędzia FancyZones]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneSetChange_MoveWindows" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[During zone layout changes, windows assigned to a zone will match new size/positions]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Podczas zmian układu stref okna przypisane do strefy zostaną dopasowane do nowego rozmiaru/położenia]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Zone_Border_Color" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone border color (Default #FFFFFF)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Kolor obramowania strefy (domyślnie #FFFFFF)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Excluded_Apps_Description" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[To exclude an application from snapping to zones add its name here (one per line). Excluded apps will react to the Windows Snap regardless of all other settings.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Aby wykluczyć aplikację z przyciągania do stref, dodaj tutaj jej nazwę (po jednej na wiersz). Wykluczone aplikacje będą reagować na funkcję przyciągania systemu Windows niezależnie od wszystkich innych ustawień.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Button" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Edit zones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Edytuj strefy]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Description" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[To launch the zone editor, select the Edit zones button below or press the zone editor hotkey anytime]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Aby uruchomić edytor stref, wybierz poniżej przycisk Edytuj strefy lub w dowolnym momencie naciśnij klawisz dostępu edytora stref]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Hotkey_Label" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Configure the zone editor hotkey]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Konfigurowanie klawisza dostępu edytora stref]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Label" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone configuration]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Konfiguracja strefy]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Settings_Highlight_Opacity" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone opacity (%)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Nieprzezroczystość strefy (%)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Span_Across_Zones_Warning" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[The 'Allow zones to span across monitors' option requires all monitors to have the same DPI scaling to work properly.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Opcja „Zezwalaj na rozciąganie stref między monitorami” do poprawnego działania wymaga, aby wszystkie monitory miały to samo skalowanie DPI.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Window_Event_Listener_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to install Windows event listener.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Nie można zainstalować odbiornika zdarzeń systemu Windows.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+    </Item>
+  </Item>
+</LCX>

src/modules/fancyzones/FancyZonesLib/loc/pt-BR/src/modules/fancyzones/lib/Resources.resx.lcl

@@ -0,0 +1,372 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LCX SchemaVersion="6.0" Name="S:\src\modules\fancyzones\FancyZonesLib\Resources.resx" PsrId="211" FileType="1" SrcCul="en-US" TgtCul="pt-BR" xmlns="http://schemas.microsoft.com/locstudio/2006/6/lcx">
+  <OwnedComments>
+    <Cmt Name="Dev" />
+    <Cmt Name="LcxAdmin" />
+    <Cmt Name="Rccx" />
+  </OwnedComments>
+  <Settings Name="@SettingsPath@\default.lss" Type="Lss" />
+  <Item ItemId=";Resources.resx" ItemType="0" PsrId="211" Leaf="false">
+    <Disp Icon="Expand" Expand="true" Disp="true" LocTbl="false" />
+    <Item ItemId=";Strings" ItemType="0" PsrId="211" Leaf="false">
+      <Disp Icon="Str" Disp="true" LocTbl="false" />
+      <Item ItemId=";Cant_Drag_Elevated" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[We've detected an application running with administrator privileges. This will prevent certain interactions with these applications.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Detectamos um aplicativo sendo executado com privilégios de administrador. Isso impedirá determinadas interações com esses aplicativos.]]></Val>
+          </Tgt>
+          <Prev Cat="Text">
+            <Val><![CDATA[We've detected an application running with administrator privileges. This blocks some functionality in PowerToys. Visit our wiki page to learn more.]]></Val>
+          </Prev>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Cant_Drag_Elevated_Dialog_Dont_Show_Again" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Don't show again]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Não mostrar novamente]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Cant_Drag_Elevated_Learn_More" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Learn more]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Saiba mais]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[FancyZones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[FancyZones]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Data_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[FancyZones persisted data path not found. Please report the bug to]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[O caminho de dados persistente do FancyZones não foi encontrado. Relate o bug para]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Editor_Launch_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[The FancyZones editor failed to start. Please report the bug to]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Falha ao iniciar o editor do FancyZones. Relate o bug para]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Settings_Load_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to load the FancyZones settings. Default settings will be used.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Falha ao carregar as configurações do FancyZones. As configurações padrão serão usadas.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Settings_Save_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to save the FancyZones settings. Please retry again later, if the problem persists report the bug to]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Falha ao salvar as configurações do FancyZones. Tente novamente mais tarde e, se o problema persistir, relate o bug para]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Keyboard_Listener_Error" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to install keyboard listener.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Falha ao instalar o ouvinte de teclado.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Powertoys_FancyZones" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[PowerToys - FancyZones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[PowerToys – FancyZones]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Create window layouts to help make multi-tasking easy]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Criar layouts da janela para facilitar multitarefas]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_AppLastZone_MoveWindows" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move newly created windows to their last known zone]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Mover as janelas recém-criadas para a última zona conhecida]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_DisplayChange_MoveWindows" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Keep windows in their zones when the screen resolution changes]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Manter as janelas nas zonas quando a resolução da tela for alterada]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_FlashZonesOnQuickSwitch" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Flash zones when switching layout]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Piscar as zonas ao mudar de layout]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Make_Dragged_Window_Transparent" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Make dragged window transparent]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Tornar a janela arrastada transparente]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_MouseSwitch" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Use a non-primary mouse button to toggle zone activation]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Use um botão do mouse não primário para alternar a ativação da zona]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Move_Window_Across_Monitors" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move windows between zones across all monitors when snapping with (Win + Arrow)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Mover as janelas entre zonas em todos os monitores ao ajustar com (Win + Seta)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Move_Windows_Based_On_Position" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move windows based on their position when snapping with (Win + Arrow)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Mover as janelas com base na posição delas ao ajustar com (Win + Seta)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Open_Window_On_Active_Monitor" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move newly created windows to the current active monitor [EXPERIMENTAL]5D;]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Mover as janelas recém-criadas para o monitor ativo atual [EXPERIMENTAL]5D;]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Override_Snap_Hotkeys" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Override Windows Snap hotkeys (Win + Arrow) to move windows between zones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Substituir as teclas de atalho de Ajuste do Windows (Win + Seta) para mover as janelas entre as zonas]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_QuickLayoutSwitch" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Enable quick layout switch]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Habilitar opção de mudança rápida de layout]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_RestoreSize" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Restore the original size of windows when unsnapping]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Restaurar o tamanho original das janelas ao desajustar]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ShiftDrag" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Hold Shift key to activate zones while dragging]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Pressione a tecla Shift para ativar zonas ao arrastar]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Show_Fancy_Zones_On_All_Monitors" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Show zones on all monitors while dragging a window]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Mostrar zonas em todos os monitores ao arrastar uma janela]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Span_Zones_Across_Monitors" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Allow zones to span across monitors (all monitors must have the same DPI scaling)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Permitir que as zonas se estendam pelos monitores (todos os monitores precisam ter o mesmo ajuste de DPI)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Use_CursorPos_Editor_StartupScreen" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Follow mouse cursor instead of focus when launching editor in a multi-screen environment]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Siga o cursor do mouse em vez do foco ao iniciar o editor em um ambiente de várias telas]]></Val>
+          </Tgt>
+          <Prev Cat="Text">
+            <Val><![CDATA[Follow mouse cursor instead of focus when launching editor in a multi screen environment]]></Val>
+          </Prev>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneColor" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone inactive color (Default #F5FCFF)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Cor inativa da zona (Padrão #F5FCFF)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneHighlightColor" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone highlight color (Default #008CFF)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Cor de realce da zona (Padrão #008CFF)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneSetChange_FlashZones" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Flash zones when the active FancyZones layout changes]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Mostrar as zonas rapidamente quando o layout de FancyZones ativo for alterado]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneSetChange_MoveWindows" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[During zone layout changes, windows assigned to a zone will match new size/positions]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Durante as alterações de layout de zona, as janelas atribuídas a uma zona corresponderão ao novo tamanho/posição]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Zone_Border_Color" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone border color (Default #FFFFFF)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Cor da borda da zona (Padrão #FFFFFF)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Excluded_Apps_Description" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[To exclude an application from snapping to zones add its name here (one per line). Excluded apps will react to the Windows Snap regardless of all other settings.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Para impedir um aplicativo de ser ajustado às zonas, adicione o nome dele aqui (um por linha). Aplicativos excluídos reagirão ao Ajuste do Windows, independentemente de todas as outras configurações.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Button" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Edit zones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Editar zonas]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Description" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[To launch the zone editor, select the Edit zones button below or press the zone editor hotkey anytime]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Para iniciar o editor de zonas, selecione o botão Editar zonas abaixo ou pressione a tecla de atalho do editor de zona a qualquer momento]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Hotkey_Label" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Configure the zone editor hotkey]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Configurar a tecla de atalho do editor de zonas]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Label" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone configuration]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Configuração de zona]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Settings_Highlight_Opacity" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone opacity (%)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Opacidade da zona (%)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Span_Across_Zones_Warning" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[The 'Allow zones to span across monitors' option requires all monitors to have the same DPI scaling to work properly.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Para funcionar corretamente, a opção 'Permitir que as zonas se estendam pelos monitores' requer que todos os monitores tenham o mesmo ajuste de DPI.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Window_Event_Listener_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to install Windows event listener.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Falha ao instalar o ouvinte de eventos do Windows.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+    </Item>
+  </Item>
+</LCX>

src/modules/fancyzones/FancyZonesLib/loc/pt-PT/src/modules/fancyzones/lib/Resources.resx.lcl

@@ -0,0 +1,372 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LCX SchemaVersion="6.0" Name="S:\src\modules\fancyzones\FancyZonesLib\Resources.resx" PsrId="211" FileType="1" SrcCul="en-US" TgtCul="pt-PT" xmlns="http://schemas.microsoft.com/locstudio/2006/6/lcx">
+  <OwnedComments>
+    <Cmt Name="Dev" />
+    <Cmt Name="LcxAdmin" />
+    <Cmt Name="Rccx" />
+  </OwnedComments>
+  <Settings Name="@SettingsPath@\default.lss" Type="Lss" />
+  <Item ItemId=";Resources.resx" ItemType="0" PsrId="211" Leaf="false">
+    <Disp Icon="Expand" Expand="true" Disp="true" LocTbl="false" />
+    <Item ItemId=";Strings" ItemType="0" PsrId="211" Leaf="false">
+      <Disp Icon="Str" Disp="true" LocTbl="false" />
+      <Item ItemId=";Cant_Drag_Elevated" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[We've detected an application running with administrator privileges. This will prevent certain interactions with these applications.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Detetámos uma aplicação que está a ser executada com privilégios administrativos, o que impedirá determinadas interações com a mesma.]]></Val>
+          </Tgt>
+          <Prev Cat="Text">
+            <Val><![CDATA[We've detected an application running with administrator privileges. This blocks some functionality in PowerToys. Visit our wiki page to learn more.]]></Val>
+          </Prev>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Cant_Drag_Elevated_Dialog_Dont_Show_Again" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Don't show again]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Não mostrar novamente]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Cant_Drag_Elevated_Learn_More" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Learn more]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Saiba mais]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[FancyZones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[FancyZones]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Data_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[FancyZones persisted data path not found. Please report the bug to]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[O caminho de dados persistentes de FancyZones não foi encontrado. Reporte o erro para]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Editor_Launch_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[The FancyZones editor failed to start. Please report the bug to]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Falha ao iniciar o editor de FancyZones. Reporte o erro para]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Settings_Load_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to load the FancyZones settings. Default settings will be used.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Falha ao carregar as definições de FancyZones. Serão utilizadas as predefinições.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Settings_Save_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to save the FancyZones settings. Please retry again later, if the problem persists report the bug to]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Falha ao guardar as definições de FancyZones. Volte a tentar mais tarde e, se o problema persistir, reporte o erro para]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Keyboard_Listener_Error" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to install keyboard listener.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Falha a instalar o serviço de escuta do teclado.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Powertoys_FancyZones" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[PowerToys - FancyZones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[PowerToys - FancyZones]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Create window layouts to help make multi-tasking easy]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Crie esquemas de janelas para ajudar a facilitar as multitarefas]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_AppLastZone_MoveWindows" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move newly created windows to their last known zone]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Mover as janelas recém-criadas para a última zona conhecida]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_DisplayChange_MoveWindows" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Keep windows in their zones when the screen resolution changes]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Manter as janelas nas respetivas zonas quando a resolução do ecrã mudar]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_FlashZonesOnQuickSwitch" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Flash zones when switching layout]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Iluminar zonas ao mudar de esquema]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Make_Dragged_Window_Transparent" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Make dragged window transparent]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Tornar a janela arrastada transparente]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_MouseSwitch" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Use a non-primary mouse button to toggle zone activation]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Utilize um botão de rato não primário para alternar a ativação da zona]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Move_Window_Across_Monitors" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move windows between zones across all monitors when snapping with (Win + Arrow)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Mover janelas entre zonas em todos os monitores ao encaixar (Windows + Seta)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Move_Windows_Based_On_Position" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move windows based on their position when snapping with (Win + Arrow)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Mover janelas com base na posição ao encaixar (Windows + Seta)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Open_Window_On_Active_Monitor" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move newly created windows to the current active monitor [EXPERIMENTAL]5D;]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Mover janelas recém-criadas para o monitor ativo atual [EXPERIMENTAL]5D;]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Override_Snap_Hotkeys" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Override Windows Snap hotkeys (Win + Arrow) to move windows between zones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Substituir atalhos do Windows Snap (Windows + Seta) para mover janelas entre zonas]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_QuickLayoutSwitch" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Enable quick layout switch]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Ativar mudança rápida de esquemas]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_RestoreSize" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Restore the original size of windows when unsnapping]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Restaurar o tamanho original das janelas ao desencaixar]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ShiftDrag" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Hold Shift key to activate zones while dragging]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Manter a tecla Shift premida para ativar zonas ao arrastar]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Show_Fancy_Zones_On_All_Monitors" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Show zones on all monitors while dragging a window]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Mostrar zonas em todos os monitores ao arrastar uma janela]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Span_Zones_Across_Monitors" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Allow zones to span across monitors (all monitors must have the same DPI scaling)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Permitir que as zonas se expandam pelos monitores (todos os monitores têm de ter o mesmo dimensionamento PPP)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Use_CursorPos_Editor_StartupScreen" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Follow mouse cursor instead of focus when launching editor in a multi-screen environment]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Siga o cursor do rato em vez do foco ao iniciar o editor num ambiente com vários ecrãs]]></Val>
+          </Tgt>
+          <Prev Cat="Text">
+            <Val><![CDATA[Follow mouse cursor instead of focus when launching editor in a multi screen environment]]></Val>
+          </Prev>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneColor" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone inactive color (Default #F5FCFF)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Cor inativa da zona (Predefinição #F5FCFF)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneHighlightColor" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone highlight color (Default #008CFF)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Cor de realce da zona (Predefinição #008CFF)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneSetChange_FlashZones" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Flash zones when the active FancyZones layout changes]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Alternar zonas quando o esquema ativo de FancyZones muda]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneSetChange_MoveWindows" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[During zone layout changes, windows assigned to a zone will match new size/positions]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Durante as alterações de esquema da zona, as janelas atribuídas a uma zona corresponderão a novos tamanhos/posições]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Zone_Border_Color" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone border color (Default #FFFFFF)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Cor de limite da zona (Predefinição #FFFFFF)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Excluded_Apps_Description" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[To exclude an application from snapping to zones add its name here (one per line). Excluded apps will react to the Windows Snap regardless of all other settings.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Para excluir uma aplicação de encaixar em zonas, adicione o nome aqui (um por linha). As aplicações excluídas reagirão ao Windows Snap independentemente de todas as outras definições.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Button" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Edit zones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Editar zonas]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Description" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[To launch the zone editor, select the Edit zones button below or press the zone editor hotkey anytime]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Para iniciar o editor de zonas, selecione o botão Editar zonas abaixo ou prima o atalho do editor de zonas a qualquer momento]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Hotkey_Label" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Configure the zone editor hotkey]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Configure o atalho do editor de zonas]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Label" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone configuration]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Configuração da zona]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Settings_Highlight_Opacity" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone opacity (%)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Opacidade da zona (%)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Span_Across_Zones_Warning" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[The 'Allow zones to span across monitors' option requires all monitors to have the same DPI scaling to work properly.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[A opção "Permitir que as zonas se expandam pelos monitores" requer que todos os monitores tenham o mesmo dimensionamento PPP para funcionar corretamente.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Window_Event_Listener_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to install Windows event listener.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Falha ao instalar o serviço de escuta de eventos do Windows.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+    </Item>
+  </Item>
+</LCX>

src/modules/fancyzones/FancyZonesLib/loc/ru/src/modules/fancyzones/lib/Resources.resx.lcl

@@ -0,0 +1,372 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LCX SchemaVersion="6.0" Name="S:\src\modules\fancyzones\FancyZonesLib\Resources.resx" PsrId="211" FileType="1" SrcCul="en-US" TgtCul="ru-RU" xmlns="http://schemas.microsoft.com/locstudio/2006/6/lcx">
+  <OwnedComments>
+    <Cmt Name="Dev" />
+    <Cmt Name="LcxAdmin" />
+    <Cmt Name="Rccx" />
+  </OwnedComments>
+  <Settings Name="@SettingsPath@\default.lss" Type="Lss" />
+  <Item ItemId=";Resources.resx" ItemType="0" PsrId="211" Leaf="false">
+    <Disp Icon="Expand" Expand="true" Disp="true" LocTbl="false" />
+    <Item ItemId=";Strings" ItemType="0" PsrId="211" Leaf="false">
+      <Disp Icon="Str" Disp="true" LocTbl="false" />
+      <Item ItemId=";Cant_Drag_Elevated" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[We've detected an application running with administrator privileges. This will prevent certain interactions with these applications.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Обнаружено приложение, работающее с правами администратора. Определенные взаимодействия с этими приложениями будут невозможны.]]></Val>
+          </Tgt>
+          <Prev Cat="Text">
+            <Val><![CDATA[We've detected an application running with administrator privileges. This blocks some functionality in PowerToys. Visit our wiki page to learn more.]]></Val>
+          </Prev>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Cant_Drag_Elevated_Dialog_Dont_Show_Again" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Don't show again]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Больше не показывать]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Cant_Drag_Elevated_Learn_More" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Learn more]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Дополнительные сведения]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[FancyZones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[FancyZones]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Data_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[FancyZones persisted data path not found. Please report the bug to]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Постоянный путь к данным FancyZones не найден. Сообщите об ошибке в]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Editor_Launch_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[The FancyZones editor failed to start. Please report the bug to]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Не удалось запустить редактор FancyZones. Сообщите об ошибке в]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Settings_Load_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to load the FancyZones settings. Default settings will be used.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Не удалось загрузить параметры FancyZones. Будут использоваться параметры по умолчанию.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Settings_Save_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to save the FancyZones settings. Please retry again later, if the problem persists report the bug to]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Не удалось сохранить параметры FancyZones. Повторите попытку позже. Если проблема сохранится, сообщите об ошибке в]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Keyboard_Listener_Error" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to install keyboard listener.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Не удалось установить прослушиватель клавиатуры.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Powertoys_FancyZones" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[PowerToys - FancyZones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[PowerToys — FancyZones]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Create window layouts to help make multi-tasking easy]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Создайте макеты окон, чтобы упростить выполнение нескольких задач.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_AppLastZone_MoveWindows" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move newly created windows to their last known zone]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Перемещать создаваемые окна в последнюю известную зону]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_DisplayChange_MoveWindows" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Keep windows in their zones when the screen resolution changes]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Оставлять окна в своих зонах при изменении разрешения экрана]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_FlashZonesOnQuickSwitch" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Flash zones when switching layout]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Выделение зон при переключении макета]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Make_Dragged_Window_Transparent" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Make dragged window transparent]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Сделать перетаскиваемое окно прозрачным]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_MouseSwitch" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Use a non-primary mouse button to toggle zone activation]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Использовать не основную кнопку мыши для активации и деактивации зоны]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Move_Window_Across_Monitors" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move windows between zones across all monitors when snapping with (Win + Arrow)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Перемещать окна между зонами на всех мониторах при прикреплении с помощью сочетания клавиша Windows+СТРЕЛКА]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Move_Windows_Based_On_Position" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move windows based on their position when snapping with (Win + Arrow)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Перемещать окна в зависимости от их положения при прикреплении с помощью сочетания клавиша Windows+клавиша со стрелкой]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Open_Window_On_Active_Monitor" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move newly created windows to the current active monitor [EXPERIMENTAL]5D;]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Перемещение создаваемых окон в текущий активный монитор [экспериментальная функция]5D;]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Override_Snap_Hotkeys" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Override Windows Snap hotkeys (Win + Arrow) to move windows between zones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Переопределите сочетания клавиш прикрепления окон (клавиша Windows+клавиша со стрелкой) для перемещения окон между зонами.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_QuickLayoutSwitch" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Enable quick layout switch]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Включение быстрого переключения макета]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_RestoreSize" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Restore the original size of windows when unsnapping]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Восстанавливать исходный размер окон при отмене прикрепления]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ShiftDrag" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Hold Shift key to activate zones while dragging]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Чтобы активировать зоны при перетаскивании, удерживайте нажатой клавишу SHIFT.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Show_Fancy_Zones_On_All_Monitors" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Show zones on all monitors while dragging a window]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Показывать зоны на всех мониторах при перетаскивании окна]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Span_Zones_Across_Monitors" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Allow zones to span across monitors (all monitors must have the same DPI scaling)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Разрешить развертывание зон на нескольких мониторах (все мониторы должны иметь одинаковое масштабирование)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Use_CursorPos_Editor_StartupScreen" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Follow mouse cursor instead of focus when launching editor in a multi-screen environment]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Учитывать положение указателя мыши, а не фокус при запуске редактора в среде с несколькими экранами]]></Val>
+          </Tgt>
+          <Prev Cat="Text">
+            <Val><![CDATA[Follow mouse cursor instead of focus when launching editor in a multi screen environment]]></Val>
+          </Prev>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneColor" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone inactive color (Default #F5FCFF)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Неактивный цвет зоны (по умолчанию #F5FCFF)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneHighlightColor" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone highlight color (Default #008CFF)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Цвет выделения зоны (по умолчанию #008CFF)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneSetChange_FlashZones" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Flash zones when the active FancyZones layout changes]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Зоны мигают при изменении активного макета FancyZones.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneSetChange_MoveWindows" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[During zone layout changes, windows assigned to a zone will match new size/positions]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[При изменении макета зоны назначенные зоне окна будут иметь новые размеры и положения.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Zone_Border_Color" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone border color (Default #FFFFFF)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Цвет границы зоны (по умолчанию #FFFFFF)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Excluded_Apps_Description" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[To exclude an application from snapping to zones add its name here (one per line). Excluded apps will react to the Windows Snap regardless of all other settings.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Чтобы исключить приложение из прикрепления к зонам, добавьте здесь его имя (по одному в строке). Исключенные приложения будут реагировать на прикрепление окон независимо от остальных параметров.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Button" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Edit zones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Изменить зоны]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Description" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[To launch the zone editor, select the Edit zones button below or press the zone editor hotkey anytime]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Чтобы запустить редактор зон, нажмите кнопку "Изменить зоны" ниже или нажмите в любой момент сочетание клавиш для вызова редактора зон.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Hotkey_Label" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Configure the zone editor hotkey]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Настроить сочетание клавиш для редактора зон]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Label" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone configuration]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Конфигурация зоны]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Settings_Highlight_Opacity" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone opacity (%)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Прозрачность зоны (%)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Span_Across_Zones_Warning" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[The 'Allow zones to span across monitors' option requires all monitors to have the same DPI scaling to work properly.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Для правильной работы параметра "Разрешить развертывание зон на нескольких мониторах" требуется, чтобы все мониторы имели одинаковое масштабирование.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Window_Event_Listener_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to install Windows event listener.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Не удалось установить прослушиватель событий Windows.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+    </Item>
+  </Item>
+</LCX>

src/modules/fancyzones/FancyZonesLib/loc/sv/src/modules/fancyzones/lib/Resources.resx.lcl

@@ -0,0 +1,372 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LCX SchemaVersion="6.0" Name="S:\src\modules\fancyzones\FancyZonesLib\Resources.resx" PsrId="211" FileType="1" SrcCul="en-US" TgtCul="sv-SE" xmlns="http://schemas.microsoft.com/locstudio/2006/6/lcx">
+  <OwnedComments>
+    <Cmt Name="Dev" />
+    <Cmt Name="LcxAdmin" />
+    <Cmt Name="Rccx" />
+  </OwnedComments>
+  <Settings Name="@SettingsPath@\default.lss" Type="Lss" />
+  <Item ItemId=";Resources.resx" ItemType="0" PsrId="211" Leaf="false">
+    <Disp Icon="Expand" Expand="true" Disp="true" LocTbl="false" />
+    <Item ItemId=";Strings" ItemType="0" PsrId="211" Leaf="false">
+      <Disp Icon="Str" Disp="true" LocTbl="false" />
+      <Item ItemId=";Cant_Drag_Elevated" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[We've detected an application running with administrator privileges. This will prevent certain interactions with these applications.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Vi har identifierat ett program som körs med administratörs privilegier. Detta förhindrar vissa interaktioner med de här programmen.]]></Val>
+          </Tgt>
+          <Prev Cat="Text">
+            <Val><![CDATA[We've detected an application running with administrator privileges. This blocks some functionality in PowerToys. Visit our wiki page to learn more.]]></Val>
+          </Prev>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Cant_Drag_Elevated_Dialog_Dont_Show_Again" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Don't show again]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Visa inte igen]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Cant_Drag_Elevated_Learn_More" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Learn more]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Läs mer]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[FancyZones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[FancyZones]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Data_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[FancyZones persisted data path not found. Please report the bug to]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[FancyZones bestående datasökvägen hittades inte. Rapportera buggen till]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Editor_Launch_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[The FancyZones editor failed to start. Please report the bug to]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Det gick inte att starta FancyZones-redigeraren. Rapportera buggen till]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Settings_Load_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to load the FancyZones settings. Default settings will be used.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Det gick inte att läsa in inställningarna för FancyZones. Standardinställningarna kommer att användas.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Settings_Save_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to save the FancyZones settings. Please retry again later, if the problem persists report the bug to]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Det gick inte att spara FancyZones-inställningarna. Försök igen senare, om problemet kvarstår rapportera det till]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Keyboard_Listener_Error" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to install keyboard listener.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Det gick inte att installera tangentbordslyssnaren.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Powertoys_FancyZones" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[PowerToys - FancyZones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[PowerToys – FancyZones]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Create window layouts to help make multi-tasking easy]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Skapa fönsterlayouter som underlättar vid multitasking]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_AppLastZone_MoveWindows" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move newly created windows to their last known zone]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Flytta nyligen skapade fönster till deras senaste kända zon]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_DisplayChange_MoveWindows" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Keep windows in their zones when the screen resolution changes]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Behåll fönstren i sina zoner när skärmupplösningen ändras]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_FlashZonesOnQuickSwitch" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Flash zones when switching layout]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Blinka zoner vid layoutväxling]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Make_Dragged_Window_Transparent" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Make dragged window transparent]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Gör fönster genomskinliga när de dras]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_MouseSwitch" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Use a non-primary mouse button to toggle zone activation]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Använd en icke-primär musknapp för att styra zonaktivering]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Move_Window_Across_Monitors" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move windows between zones across all monitors when snapping with (Win + Arrow)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Flytta fönster mellan zoner över alla bildskärmar vid fästning med (Win + piltangent)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Move_Windows_Based_On_Position" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move windows based on their position when snapping with (Win + Arrow)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Flytta fönster baserat på deras placering när de fästs med (Win + piltangent)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Open_Window_On_Active_Monitor" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move newly created windows to the current active monitor [EXPERIMENTAL]5D;]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Flytta nyligen skapade fönster till den bildskärm som är aktiv för tillfället [Experimentellt]5D;]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Override_Snap_Hotkeys" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Override Windows Snap hotkeys (Win + Arrow) to move windows between zones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Åsidosätt Windows Snap-snabbtangenter (Win + piltangent) för att flytta fönster mellan zoner]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_QuickLayoutSwitch" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Enable quick layout switch]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Aktivera snabb layoutväxling]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_RestoreSize" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Restore the original size of windows when unsnapping]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Återställ den ursprungliga storleken för fönster när de frigörs]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ShiftDrag" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Hold Shift key to activate zones while dragging]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Håll ned skift-tangenten om du vill aktivera zoner medan du drar]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Show_Fancy_Zones_On_All_Monitors" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Show zones on all monitors while dragging a window]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Visa zoner på alla skärmar när du drar ett fönster]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Span_Zones_Across_Monitors" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Allow zones to span across monitors (all monitors must have the same DPI scaling)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Tillåt att zoner sträcker sig över flera bildskärmar (alla bildskärmar måste ha samma DPI-skalning)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Use_CursorPos_Editor_StartupScreen" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Follow mouse cursor instead of focus when launching editor in a multi-screen environment]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Följ musmarkören i stället för fokusmarkören när du startar redigeringsprogrammet i en flerskärmsmiljö]]></Val>
+          </Tgt>
+          <Prev Cat="Text">
+            <Val><![CDATA[Follow mouse cursor instead of focus when launching editor in a multi screen environment]]></Val>
+          </Prev>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneColor" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone inactive color (Default #F5FCFF)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Färg för inaktiv zon (standardinställning #F5FCFF)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneHighlightColor" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone highlight color (Default #008CFF)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Färg vid zonmarkering (standardinställning #008CFF)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneSetChange_FlashZones" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Flash zones when the active FancyZones layout changes]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Blixtra zoner när den aktiva FancyZones-layouten ändras]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneSetChange_MoveWindows" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[During zone layout changes, windows assigned to a zone will match new size/positions]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Vid zonlayoutändringar kommer fönster som tilldelats en zon att matcha nya storlekar/positioner]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Zone_Border_Color" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone border color (Default #FFFFFF)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Zonens kantlinjefärg (standardinställning #FFFFFF)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Excluded_Apps_Description" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[To exclude an application from snapping to zones add its name here (one per line). Excluded apps will react to the Windows Snap regardless of all other settings.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Om du vill undanta ett program från att fästas mot zoner lägger du till namnet här (ett per rad). Undantagna appar reagerar på Windows Snap oavsett övriga inställningar.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Button" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Edit zones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Redigera zoner]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Description" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[To launch the zone editor, select the Edit zones button below or press the zone editor hotkey anytime]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Om du vill starta zonredigeraren väljer du knappen Redigera zoner nedan eller trycker på snabbtangenten för zonredigeraren när som helst]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Hotkey_Label" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Configure the zone editor hotkey]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Konfigurera snabbtangent för zonredigeraren]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Label" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone configuration]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Zonkonfiguration]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Settings_Highlight_Opacity" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone opacity (%)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Zonogenomskinlighet (%)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Span_Across_Zones_Warning" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[The 'Allow zones to span across monitors' option requires all monitors to have the same DPI scaling to work properly.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Alternativet Tillåt zoner att spänna över flera bildskärmar kräver att alla skärmar har samma DPI-skalning för att fungera korrekt.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Window_Event_Listener_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to install Windows event listener.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Det gick inte att installera Windows-händelselyssnaren.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+    </Item>
+  </Item>
+</LCX>

src/modules/fancyzones/FancyZonesLib/loc/tr/src/modules/fancyzones/lib/Resources.resx.lcl

@@ -0,0 +1,372 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LCX SchemaVersion="6.0" Name="S:\src\modules\fancyzones\FancyZonesLib\Resources.resx" PsrId="211" FileType="1" SrcCul="en-US" TgtCul="tr-TR" xmlns="http://schemas.microsoft.com/locstudio/2006/6/lcx">
+  <OwnedComments>
+    <Cmt Name="Dev" />
+    <Cmt Name="LcxAdmin" />
+    <Cmt Name="Rccx" />
+  </OwnedComments>
+  <Settings Name="@SettingsPath@\default.lss" Type="Lss" />
+  <Item ItemId=";Resources.resx" ItemType="0" PsrId="211" Leaf="false">
+    <Disp Icon="Expand" Expand="true" Disp="true" LocTbl="false" />
+    <Item ItemId=";Strings" ItemType="0" PsrId="211" Leaf="false">
+      <Disp Icon="Str" Disp="true" LocTbl="false" />
+      <Item ItemId=";Cant_Drag_Elevated" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[We've detected an application running with administrator privileges. This will prevent certain interactions with these applications.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Bir uygulamanın yönetici ayrıcalıklarıyla çalıştırıldığını algıladık. Bu, ilgili uygulamayla belirli etkileşimleri engelleyecektir.]]></Val>
+          </Tgt>
+          <Prev Cat="Text">
+            <Val><![CDATA[We've detected an application running with administrator privileges. This blocks some functionality in PowerToys. Visit our wiki page to learn more.]]></Val>
+          </Prev>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Cant_Drag_Elevated_Dialog_Dont_Show_Again" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Don't show again]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Bir daha gösterme]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Cant_Drag_Elevated_Learn_More" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Learn more]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Daha fazla bilgi]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[FancyZones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[FancyZones]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Data_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[FancyZones persisted data path not found. Please report the bug to]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[FancyZones kalıcı veri yolu bulunamadı. Lütfen hatayı şuraya bildirin:]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Editor_Launch_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[The FancyZones editor failed to start. Please report the bug to]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[FancyZones düzenleyicisi başlatılamadı. Lütfen hatayı şuraya bildirin:]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Settings_Load_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to load the FancyZones settings. Default settings will be used.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[FancyZones ayarları yüklenemedi. Varsayılan ayarlar kullanılacak.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Settings_Save_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to save the FancyZones settings. Please retry again later, if the problem persists report the bug to]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[FancyZones ayarları kaydedilemedi. Lütfen daha sonra yeniden deneyin, sorun devam ederse hatayı şuraya bildirin:]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Keyboard_Listener_Error" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to install keyboard listener.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Klavye dinleyicisi yüklenemedi.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Powertoys_FancyZones" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[PowerToys - FancyZones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[PowerToys - FancyZones]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Create window layouts to help make multi-tasking easy]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Çoklu görev kullanımını kolaylaştırmak için pencere düzenleri oluşturun]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_AppLastZone_MoveWindows" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move newly created windows to their last known zone]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Yeni oluşturulan pencereyi bilinen son bölgesine taşı]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_DisplayChange_MoveWindows" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Keep windows in their zones when the screen resolution changes]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Ekran çözünürlüğü değiştiğinde pencereleri kendi bölgelerinde tut]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_FlashZonesOnQuickSwitch" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Flash zones when switching layout]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Düzen değiştirilirken bölgeleri parlamayla gösterin]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Make_Dragged_Window_Transparent" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Make dragged window transparent]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Sürüklenen pencereyi saydam yap]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_MouseSwitch" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Use a non-primary mouse button to toggle zone activation]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Bölge etkinleştirmesini değiştirmek için birincil olmayan fare düğmesini kullanın]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Move_Window_Across_Monitors" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move windows between zones across all monitors when snapping with (Win + Arrow)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[(Windows Tuşu + Ok) ile tutturulurken pencereleri tüm monitörlerde bölgeler arasında taşı]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Move_Windows_Based_On_Position" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move windows based on their position when snapping with (Win + Arrow)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[(Windows Tuşu + Ok) ile tutturulurken pencereleri konumlarına göre taşı]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Open_Window_On_Active_Monitor" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move newly created windows to the current active monitor [EXPERIMENTAL]5D;]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Yeni oluşturulan pencereleri geçerli etkin monitöre taşı [DENEYSEL]5D;]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Override_Snap_Hotkeys" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Override Windows Snap hotkeys (Win + Arrow) to move windows between zones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Pencereleri bölgeler arasında taşımak için Windows Snap kısayol tuşlarını (Windows Tuşu + Ok) geçersiz kılın]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_QuickLayoutSwitch" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Enable quick layout switch]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Hızlı düzen anahtarını etkinleştirin]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_RestoreSize" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Restore the original size of windows when unsnapping]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Tutturulması kaldırılırken pencerelerin özgün boyutunu geri yükle]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ShiftDrag" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Hold Shift key to activate zones while dragging]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Bölgeleri sürüklerken etkinleştirmek için Shift tuşuna basılı tutun]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Show_Fancy_Zones_On_All_Monitors" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Show zones on all monitors while dragging a window]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Pencereyi sürüklerken tüm monitörlerdeki bölgeleri göster]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Span_Zones_Across_Monitors" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Allow zones to span across monitors (all monitors must have the same DPI scaling)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Bölgelerin monitörler arasında yayılmasına izin ver (tüm monitörler aynı DPI ölçeklendirmesine sahip olmalıdır)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Use_CursorPos_Editor_StartupScreen" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Follow mouse cursor instead of focus when launching editor in a multi-screen environment]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Düzenleyiciyi çok ekranlı bir ortamda başlatırken odak yerine fare imlecini izle]]></Val>
+          </Tgt>
+          <Prev Cat="Text">
+            <Val><![CDATA[Follow mouse cursor instead of focus when launching editor in a multi screen environment]]></Val>
+          </Prev>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneColor" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone inactive color (Default #F5FCFF)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Etkin olmayan bölge rengi (Varsayılan #F5FCFF)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneHighlightColor" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone highlight color (Default #008CFF)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Bölge vurgulama rengi (Varsayılan #008CFF)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneSetChange_FlashZones" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Flash zones when the active FancyZones layout changes]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Etkin FancyZones düzeni değiştiğinde görünen Flash bölgeleri]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneSetChange_MoveWindows" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[During zone layout changes, windows assigned to a zone will match new size/positions]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Bölge düzeni değişiklikleri sırasında bir bölgeye atanan pencereler yeni boyut/pozisyonlar ile eşleşir]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Zone_Border_Color" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone border color (Default #FFFFFF)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Bölge kenarlık rengi (Varsayılan #FFFFFF)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Excluded_Apps_Description" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[To exclude an application from snapping to zones add its name here (one per line). Excluded apps will react to the Windows Snap regardless of all other settings.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Uygulamayı bölgelere tutturma özelliğinden dışlamak için adını buraya ekleyin (her satıra bir uygulama). Dışlanan uygulamalar diğer tüm ayarlardan bağımsız olarak Windows Snap'e tepki verir.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Button" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Edit zones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Bölgeleri düzenle]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Description" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[To launch the zone editor, select the Edit zones button below or press the zone editor hotkey anytime]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Bölge düzenleyicisini başlatmak için aşağıdaki Alanları düzenle düğmesini seçin veya istediğiniz zaman bölge düzenleyicisi kısayol tuşuna basın]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Hotkey_Label" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Configure the zone editor hotkey]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Bölge düzenleyicisi kısayol tuşunu yapılandır]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Label" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone configuration]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Bölge yapılandırması]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Settings_Highlight_Opacity" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone opacity (%)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Bölge opaklığı yüzdesi]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Span_Across_Zones_Warning" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[The 'Allow zones to span across monitors' option requires all monitors to have the same DPI scaling to work properly.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA['Bölgelerin monitörler arasında yayılmasına izin ver' seçeneğinin düzgün çalışabilmesi için tüm monitörlerin aynı DPI ölçeklendirmesine sahip olmasını gerekir.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Window_Event_Listener_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to install Windows event listener.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Windows olay dinleyicisi yüklenemedi.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+    </Item>
+  </Item>
+</LCX>

src/modules/fancyzones/FancyZonesLib/loc/zh-Hans/src/modules/fancyzones/lib/Resources.resx.lcl

@@ -0,0 +1,372 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LCX SchemaVersion="6.0" Name="S:\src\modules\fancyzones\FancyZonesLib\Resources.resx" PsrId="211" FileType="1" SrcCul="en-US" TgtCul="zh-CN" xmlns="http://schemas.microsoft.com/locstudio/2006/6/lcx">
+  <OwnedComments>
+    <Cmt Name="Dev" />
+    <Cmt Name="LcxAdmin" />
+    <Cmt Name="Rccx" />
+  </OwnedComments>
+  <Settings Name="@SettingsPath@\default.lss" Type="Lss" />
+  <Item ItemId=";Resources.resx" ItemType="0" PsrId="211" Leaf="false">
+    <Disp Icon="Expand" Expand="true" Disp="true" LocTbl="false" />
+    <Item ItemId=";Strings" ItemType="0" PsrId="211" Leaf="false">
+      <Disp Icon="Str" Disp="true" LocTbl="false" />
+      <Item ItemId=";Cant_Drag_Elevated" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[We've detected an application running with administrator privileges. This will prevent certain interactions with these applications.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[我们检测到以管理员特权运行的应用程序。这将阻止与这些应用程序进行某些交互。]]></Val>
+          </Tgt>
+          <Prev Cat="Text">
+            <Val><![CDATA[We've detected an application running with administrator privileges. This blocks some functionality in PowerToys. Visit our wiki page to learn more.]]></Val>
+          </Prev>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Cant_Drag_Elevated_Dialog_Dont_Show_Again" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Don't show again]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[不再显示]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Cant_Drag_Elevated_Learn_More" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Learn more]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[了解更多]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[FancyZones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[FancyZones]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Data_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[FancyZones persisted data path not found. Please report the bug to]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[找不到 FancyZones 持久化数据路径。请将 bug 报告给]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Editor_Launch_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[The FancyZones editor failed to start. Please report the bug to]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[无法启动 FancyZones 编辑器。请将 bug 报告给]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Settings_Load_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to load the FancyZones settings. Default settings will be used.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[无法加载 FancyZones 设置。将使用默认设置。]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Settings_Save_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to save the FancyZones settings. Please retry again later, if the problem persists report the bug to]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[无法保存 FancyZones 设置。请稍后重试。如果此问题仍然存在，请将 bug 报告给]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Keyboard_Listener_Error" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to install keyboard listener.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[无法安装键盘侦听器。]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Powertoys_FancyZones" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[PowerToys - FancyZones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[PowerToys - FancyZones]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Create window layouts to help make multi-tasking easy]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[创建窗口布局，以帮助简化多任务处理]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_AppLastZone_MoveWindows" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move newly created windows to their last known zone]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[将新创建的窗口移动到上一个已知区域]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_DisplayChange_MoveWindows" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Keep windows in their zones when the screen resolution changes]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[当屏幕分辨率发生变化时，使窗口保持在各自的区域内]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_FlashZonesOnQuickSwitch" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Flash zones when switching layout]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[切换布局时刷写区域]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Make_Dragged_Window_Transparent" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Make dragged window transparent]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[让被拖动的窗口透明]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_MouseSwitch" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Use a non-primary mouse button to toggle zone activation]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[使用次要鼠标按钮来切换区域激活]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Move_Window_Across_Monitors" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move windows between zones across all monitors when snapping with (Win + Arrow)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[在使用(Win+箭头)贴靠时，跨所有监视器在区域之间移动窗口]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Move_Windows_Based_On_Position" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move windows based on their position when snapping with (Win + Arrow)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[在使用(Win+箭头)贴靠时，根据窗口位置移动窗口]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Open_Window_On_Active_Monitor" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move newly created windows to the current active monitor [EXPERIMENTAL]5D;]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[将新创建的窗口移动到当前活动的监视器[实验性]5D;]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Override_Snap_Hotkeys" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Override Windows Snap hotkeys (Win + Arrow) to move windows between zones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[替代 Windows Snap 热键(Win+箭头)以在区域之间移动窗口]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_QuickLayoutSwitch" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Enable quick layout switch]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[启用快速布局切换]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_RestoreSize" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Restore the original size of windows when unsnapping]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[在取消贴靠时还原窗口的原始大小]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ShiftDrag" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Hold Shift key to activate zones while dragging]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[在拖动时按住 Shift 键来激活区域]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Show_Fancy_Zones_On_All_Monitors" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Show zones on all monitors while dragging a window]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[在拖动窗口时在所有监视器上显示区域]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Span_Zones_Across_Monitors" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Allow zones to span across monitors (all monitors must have the same DPI scaling)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[允许区域跨监视器(所有监视器都必须有相同的 DPI 缩放) ]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Use_CursorPos_Editor_StartupScreen" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Follow mouse cursor instead of focus when launching editor in a multi-screen environment]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[在多屏环境中启动编辑器时，跟随鼠标光标，而不是焦点]]></Val>
+          </Tgt>
+          <Prev Cat="Text">
+            <Val><![CDATA[Follow mouse cursor instead of focus when launching editor in a multi screen environment]]></Val>
+          </Prev>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneColor" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone inactive color (Default #F5FCFF)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[区域非活动颜色(默认值: #F5FCFF) ]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneHighlightColor" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone highlight color (Default #008CFF)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[区域突出显示颜色(默认值: #008CFF) ]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneSetChange_FlashZones" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Flash zones when the active FancyZones layout changes]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[在活动 FancyZones 布局变化时闪烁区域]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneSetChange_MoveWindows" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[During zone layout changes, windows assigned to a zone will match new size/positions]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[在区域布局变化时，分配给区域的窗口将匹配新的大小/位置]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Zone_Border_Color" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone border color (Default #FFFFFF)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[区域边框颜色(默认值: #FFFFFF) ]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Excluded_Apps_Description" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[To exclude an application from snapping to zones add its name here (one per line). Excluded apps will react to the Windows Snap regardless of all other settings.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[若要排除应用程序以阻止它贴靠到区域，请在此处添加它的名称(每行一个)。不管其他任何设置如何，被排除的应用程序都将只会对 Windows Snap 做出反应。]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Button" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Edit zones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[编辑区域]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Description" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[To launch the zone editor, select the Edit zones button below or press the zone editor hotkey anytime]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[若要启动区域编辑器，请选择下面的“编辑区域”按钮，或者随时都可以按区域编辑器热键]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Hotkey_Label" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Configure the zone editor hotkey]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[配置区域编辑器热键]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Label" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone configuration]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[区域配置]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Settings_Highlight_Opacity" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone opacity (%)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[区域不透明度(%) ]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Span_Across_Zones_Warning" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[The 'Allow zones to span across monitors' option requires all monitors to have the same DPI scaling to work properly.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[“允许区域跨监视器”选项要求所有监视器都必须有相同的 DPI 缩放才能正常运行。]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Window_Event_Listener_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to install Windows event listener.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[无法安装 Windows 事件侦听器。]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+    </Item>
+  </Item>
+</LCX>

src/modules/fancyzones/FancyZonesLib/loc/zh-Hant/src/modules/fancyzones/lib/Resources.resx.lcl

@@ -0,0 +1,372 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LCX SchemaVersion="6.0" Name="S:\src\modules\fancyzones\FancyZonesLib\Resources.resx" PsrId="211" FileType="1" SrcCul="en-US" TgtCul="zh-TW" xmlns="http://schemas.microsoft.com/locstudio/2006/6/lcx">
+  <OwnedComments>
+    <Cmt Name="Dev" />
+    <Cmt Name="LcxAdmin" />
+    <Cmt Name="Rccx" />
+  </OwnedComments>
+  <Settings Name="@SettingsPath@\default.lss" Type="Lss" />
+  <Item ItemId=";Resources.resx" ItemType="0" PsrId="211" Leaf="false">
+    <Disp Icon="Expand" Expand="true" Disp="true" LocTbl="false" />
+    <Item ItemId=";Strings" ItemType="0" PsrId="211" Leaf="false">
+      <Disp Icon="Str" Disp="true" LocTbl="false" />
+      <Item ItemId=";Cant_Drag_Elevated" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[We've detected an application running with administrator privileges. This will prevent certain interactions with these applications.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[我們偵測到執行系統管理員權限的應用程式。這會禁止這些應用程式的特定互動。]]></Val>
+          </Tgt>
+          <Prev Cat="Text">
+            <Val><![CDATA[We've detected an application running with administrator privileges. This blocks some functionality in PowerToys. Visit our wiki page to learn more.]]></Val>
+          </Prev>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Cant_Drag_Elevated_Dialog_Dont_Show_Again" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Don't show again]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[不要再顯示]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Cant_Drag_Elevated_Learn_More" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Learn more]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[深入了解]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[FancyZones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[FancyZones]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Data_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[FancyZones persisted data path not found. Please report the bug to]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[找不到 FancyZones 保存的資料路徑。請將此 Bug 回報給]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Editor_Launch_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[The FancyZones editor failed to start. Please report the bug to]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[FancyZones 編輯器無法啟動。請將此 Bug 回報給]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Settings_Load_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to load the FancyZones settings. Default settings will be used.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[無法載入 FancyZones 設定。將使用預設設定。]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";FancyZones_Settings_Save_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to save the FancyZones settings. Please retry again later, if the problem persists report the bug to]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[無法儲存 FancyZones 設定。請稍後重試。若問題持續發生，請將此 Bug 回報給]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Keyboard_Listener_Error" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to install keyboard listener.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[無法安裝鍵盤接聽程式。]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Powertoys_FancyZones" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[PowerToys - FancyZones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[PowerToys - FancyZones]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Create window layouts to help make multi-tasking easy]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[建立視窗配置，以利多工作業進行]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_AppLastZone_MoveWindows" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move newly created windows to their last known zone]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[將新建立的視窗移至其上次的所在區域]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_DisplayChange_MoveWindows" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Keep windows in their zones when the screen resolution changes]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[當螢幕解析度變更時，將視窗保留在其區域中]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_FlashZonesOnQuickSwitch" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Flash zones when switching layout]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[切換版面配置時的 Flash 區域]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Make_Dragged_Window_Transparent" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Make dragged window transparent]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[將拖曳的視窗設為透明]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_MouseSwitch" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Use a non-primary mouse button to toggle zone activation]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[使用非主要滑鼠按鈕切換所要啟用的區域]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Move_Window_Across_Monitors" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move windows between zones across all monitors when snapping with (Win + Arrow)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[在所有監視器的區域之間移動視窗對齊 (Win + 方向鍵)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Move_Windows_Based_On_Position" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move windows based on their position when snapping with (Win + Arrow)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[對齊時依據視窗的位置移動視窗 (Win + 方向鍵)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Open_Window_On_Active_Monitor" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Move newly created windows to the current active monitor [EXPERIMENTAL]5D;]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[將新建立的視窗移至目前正在使用的監視器 [實驗性]5D;]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Override_Snap_Hotkeys" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Override Windows Snap hotkeys (Win + Arrow) to move windows between zones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[覆寫 Windows Snap 快速鍵 (Win + 方向鍵)，以在區域之間移動視窗]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_QuickLayoutSwitch" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Enable quick layout switch]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[啟用快速版面配置切換]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_RestoreSize" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Restore the original size of windows when unsnapping]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[取消貼齊時還原成原始視窗大小]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ShiftDrag" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Hold Shift key to activate zones while dragging]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[拖曳時按住 Shift 鍵可啟用區域]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Show_Fancy_Zones_On_All_Monitors" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Show zones on all monitors while dragging a window]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[拖曳視窗時顯示所有監視器上的區域]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Span_Zones_Across_Monitors" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Allow zones to span across monitors (all monitors must have the same DPI scaling)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[允許區域擴展到不同的監視器 (所有監視器的 DPI 縮放比例必須相同)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Use_CursorPos_Editor_StartupScreen" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Follow mouse cursor instead of focus when launching editor in a multi-screen environment]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[當在多重螢幕環境中啟動編輯器時，跟隨滑鼠游標而非焦點]]></Val>
+          </Tgt>
+          <Prev Cat="Text">
+            <Val><![CDATA[Follow mouse cursor instead of focus when launching editor in a multi screen environment]]></Val>
+          </Prev>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneColor" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone inactive color (Default #F5FCFF)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[非使用中區域的色彩 (預設: #F5FCFF)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneHighlightColor" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone highlight color (Default #008CFF)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[區域醒目提示的色彩 (預設: #008CFF)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneSetChange_FlashZones" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Flash zones when the active FancyZones layout changes]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[當使用中之 FancyZones 的配置變更時閃爍區域]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_ZoneSetChange_MoveWindows" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[During zone layout changes, windows assigned to a zone will match new size/positions]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[當區域配置變更時，指派給區域的視窗將會符合新的大小/位置]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Description_Zone_Border_Color" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone border color (Default #FFFFFF)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[區域框線的色彩 (預設: #FFFFFF)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Excluded_Apps_Description" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[To exclude an application from snapping to zones add its name here (one per line). Excluded apps will react to the Windows Snap regardless of all other settings.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[若要排除與區域貼齊的應用程式，請在此新增其名稱 (每行一個)。無論所有其他設定如何，排除的應用程式只會回應 Windows Snap。]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Button" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Edit zones]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[編輯區域]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Description" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[To launch the zone editor, select the Edit zones button below or press the zone editor hotkey anytime]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[若要啟動區域編輯器，請選取下方的 [編輯區域]5D; 按鈕，或隨時按區域編輯器快速鍵]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Hotkey_Label" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Configure the zone editor hotkey]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[設定區域編輯器快速鍵]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Setting_Launch_Editor_Label" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone configuration]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[區域設定]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Settings_Highlight_Opacity" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Zone opacity (%)]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[區域的不透明度 (%)]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Span_Across_Zones_Warning" ItemType="0;.resx" PsrId="211" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[The 'Allow zones to span across monitors' option requires all monitors to have the same DPI scaling to work properly.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[[允許區域擴展到不同的監視器]5D; 選項要求所有監視器的 DPI 縮放比例必須相同，才能正常運作。]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+      <Item ItemId=";Window_Event_Listener_Error" ItemType="0;.resx" PsrId="211" InstFlg="true" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[Failed to install Windows event listener.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[無法安裝 Windows 事件接聽程式。]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
+    </Item>
+  </Item>
+</LCX>

src/modules/fancyzones/FancyZonesLib/on_thread_executor.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <future>
+#include <thread>
+#include <functional>
+#include <queue>
+#include <atomic>
+
+// OnThreadExecutor allows its caller to off-load some work to a persistently running background thread.
+// This might come in handy if you use the API which sets thread-wide global state and the state needs
+// to be isolated.
+
+class OnThreadExecutor final
+{
+public:
+    using task_t = std::packaged_task<void()>;
+
+    OnThreadExecutor();
+    ~OnThreadExecutor();
+    std::future<void> submit(task_t task);
+    void cancel();
+
+private:
+    void worker_thread();
+
+    std::mutex _task_mutex;
+    std::condition_variable _task_cv;
+    std::atomic_bool _shutdown_request;
+    std::queue<std::packaged_task<void()>> _task_queue;
+    std::thread _worker_thread;
+};

src/modules/fancyzones/FancyZonesLib/packages.config

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

src/modules/fancyzones/FancyZonesLib/pch.cpp

@@ -0,0 +1,5 @@
+// pch.cpp: source file corresponding to the pre-compiled header
+
+#include "pch.h"
+
+// When you are using pre-compiled headers, this source file is necessary for compilation to succeed.

src/modules/fancyzones/FancyZonesLib/pch.h

@@ -0,0 +1,29 @@
+#pragma once
+#include "Generated Files/resource.h"
+
+#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers
+#include <Unknwn.h>
+#include <winrt/base.h>
+#include <winrt/Windows.Foundation.Collections.h>
+#include <windows.h>
+#include <windowsx.h>
+#include <dwmapi.h>
+#include <ProjectTelemetry.h>
+#include <shellapi.h>
+#include <ShellScalingApi.h>
+#include <strsafe.h>
+#include <TraceLoggingActivity.h>
+#include <wil\resource.h>
+#include <wil\result.h>
+#include <winrt/windows.foundation.h>
+#include <psapi.h>
+#include <shared_mutex>
+#include <functional>
+#include <unordered_set>
+#include <ShObjIdl.h>
+#include <optional>
+
+namespace winrt
+{
+    using namespace ::winrt;
+}

src/modules/fancyzones/FancyZonesLib/resource.base.h

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

src/modules/fancyzones/FancyZonesLib/trace.cpp

@@ -0,0 +1,332 @@
+#include "pch.h"
+#include "trace.h"
+#include "FancyZonesLib/ZoneSet.h"
+#include "FancyZonesLib/Settings.h"
+#include "FancyZonesLib/FancyZonesData.h"
+#include "FancyZonesLib/FancyZonesDataTypes.h"
+
+// Telemetry strings should not be localized.
+#define LoggingProviderKey "Microsoft.PowerToys"
+
+#define EventEnableFancyZonesKey "FancyZones_EnableFancyZones"
+#define EventKeyDownKey "FancyZones_OnKeyDown"
+#define EventZoneSettingsChangedKey "FancyZones_ZoneSettingsChanged"
+#define EventEditorLaunchKey "FancyZones_EditorLaunch"
+#define EventSettingsKey "FancyZones_Settings"
+#define EventDesktopChangedKey "FancyZones_VirtualDesktopChanged"
+#define EventZoneWindowKeyUpKey "FancyZones_ZoneWindowKeyUp"
+#define EventMoveSizeEndKey "FancyZones_MoveSizeEnd"
+#define EventCycleActiveZoneSetKey "FancyZones_CycleActiveZoneSet"
+#define EventQuickLayoutSwitchKey "FancyZones_QuickLayoutSwitch"
+
+#define EventEnabledKey "Enabled"
+#define PressedKeyCodeKey "Hotkey"
+#define PressedWindowKey "WindowsKey"
+#define PressedControlKey "ControlKey"
+#define MoveSizeActionKey "InMoveSize"
+#define AppsInHistoryCountKey "AppsInHistoryCount"
+#define CustomZoneSetCountKey "CustomZoneSetCount"
+#define LayoutUsingQuickKeyCountKey "LayoutUsingQuickKeyCount"
+#define NumberOfZonesForEachCustomZoneSetKey "NumberOfZonesForEachCustomZoneSet"
+#define ActiveZoneSetsCountKey "ActiveZoneSetsCount"
+#define ActiveZoneSetsListKey "ActiveZoneSetsList"
+#define EditorLaunchValueKey "Value"
+#define ShiftDragKey "ShiftDrag"
+#define MouseSwitchKey "MouseSwitch"
+#define MoveWindowsOnDisplayChangeKey "MoveWindowsOnDisplayChange"
+#define FlashZonesOnZoneSetChangeKey "FlashZonesOnZoneSetChange"
+#define MoveWindowsOnZoneSetChangeKey "MoveWindowsOnZoneSetChange"
+#define OverrideSnapHotKeysKey "OverrideSnapHotKeys"
+#define MoveWindowAcrossMonitorsKey "MoveWindowAcrossMonitors"
+#define MoveWindowsBasedOnPositionKey "MoveWindowsBasedOnPosition"
+#define MoveWindowsToLastZoneOnAppOpeningKey "MoveWindowsToLastZoneOnAppOpening"
+#define OpenWindowOnActiveMonitorKey "OpenWindowOnActiveMonitor"
+#define RestoreSizeKey "RestoreSize"
+#define QuickLayoutSwitchKey "QuickLayoutSwitch"
+#define FlashZonesOnQuickSwitchKey "FlashZonesOnQuickSwitch"
+#define UseCursorPosOnEditorStartupKey "UseCursorPosOnEditorStartup"
+#define ShowZonesOnAllMonitorsKey "ShowZonesOnAllMonitors"
+#define SpanZonesAcrossMonitorsKey "SpanZonesAcrossMonitors"
+#define MakeDraggedWindowTransparentKey "MakeDraggedWindowTransparent"
+#define ZoneColorKey "ZoneColor"
+#define ZoneBorderColorKey "ZoneBorderColor"
+#define ZoneHighlightColorKey "ZoneHighlightColor"
+#define ZoneHighlightOpacityKey "ZoneHighlightOpacity"
+#define HotkeyKey "Hotkey"
+#define ExcludedAppsCountKey "ExcludedAppsCount"
+#define KeyboardValueKey "KeyboardValue"
+#define ActiveSetKey "ActiveSet"
+#define NumberOfZonesKey "NumberOfZones"
+#define NumberOfWindowsKey "NumberOfWindows"
+#define InputModeKey "InputMode"
+#define OverlappingZonesAlgorithmKey "OverlappingZonesAlgorithm"
+#define QuickLayoutSwitchedWithShortcutUsed "ShortcutUsed"
+
+TRACELOGGING_DEFINE_PROVIDER(
+    g_hProvider,
+    LoggingProviderKey,
+    // {38e8889b-9731-53f5-e901-e8a7c1753074}
+    (0x38e8889b, 0x9731, 0x53f5, 0xe9, 0x01, 0xe8, 0xa7, 0xc1, 0x75, 0x30, 0x74),
+    TraceLoggingOptionProjectTelemetry());
+
+struct ZoneSetInfo
+{
+    size_t NumberOfZones = 0;
+    size_t NumberOfWindows = 0;
+};
+
+ZoneSetInfo GetZoneSetInfo(_In_opt_ winrt::com_ptr<IZoneSet> set) noexcept
+{
+    ZoneSetInfo info;
+    if (set)
+    {
+        auto zones = set->GetZones();
+        info.NumberOfZones = zones.size();
+        info.NumberOfWindows = 0;
+        for (int i = 0; i < static_cast<int>(zones.size()); i++)
+        {
+            if (!set->IsZoneEmpty(i))
+            {
+                info.NumberOfWindows++;
+            }
+        }
+    }
+    return info;
+}
+
+void Trace::RegisterProvider() noexcept
+{
+    TraceLoggingRegister(g_hProvider);
+}
+
+void Trace::UnregisterProvider() noexcept
+{
+    TraceLoggingUnregister(g_hProvider);
+}
+
+void Trace::FancyZones::EnableFancyZones(bool enabled) noexcept
+{
+    TraceLoggingWrite(
+        g_hProvider,
+        EventEnableFancyZonesKey,
+        ProjectTelemetryPrivacyDataTag(ProjectTelemetryTag_ProductAndServicePerformance),
+        TraceLoggingKeyword(PROJECT_KEYWORD_MEASURE),
+        TraceLoggingBoolean(enabled, EventEnabledKey));
+}
+
+void Trace::FancyZones::OnKeyDown(DWORD vkCode, bool win, bool control, bool inMoveSize) noexcept
+{
+    TraceLoggingWrite(
+        g_hProvider,
+        EventKeyDownKey,
+        ProjectTelemetryPrivacyDataTag(ProjectTelemetryTag_ProductAndServicePerformance),
+        TraceLoggingKeyword(PROJECT_KEYWORD_MEASURE),
+        TraceLoggingValue(vkCode, PressedKeyCodeKey),
+        TraceLoggingBoolean(win, PressedWindowKey),
+        TraceLoggingBoolean(control, PressedControlKey),
+        TraceLoggingBoolean(inMoveSize, MoveSizeActionKey));
+}
+
+void Trace::FancyZones::DataChanged() noexcept
+{
+    const FancyZonesData& data = FancyZonesDataInstance();
+    int appsHistorySize = static_cast<int>(data.GetAppZoneHistoryMap().size());
+    const auto& customZones = data.GetCustomZoneSetsMap();
+    const auto& devices = data.GetDeviceInfoMap();
+    const auto& quickKeys = data.GetLayoutQuickKeys();
+
+    std::unique_ptr<INT32[]> customZonesArray(new (std::nothrow) INT32[customZones.size()]);
+    if (!customZonesArray)
+    {
+        return;
+    }
+
+    auto getCustomZoneCount = [&data](const std::variant<FancyZonesDataTypes::CanvasLayoutInfo, FancyZonesDataTypes::GridLayoutInfo>& layoutInfo) -> int {
+        if (std::holds_alternative<FancyZonesDataTypes::GridLayoutInfo>(layoutInfo))
+        {
+            const auto& info = std::get<FancyZonesDataTypes::GridLayoutInfo>(layoutInfo);
+            return (info.rows() * info.columns());
+        }
+        else if (std::holds_alternative<FancyZonesDataTypes::CanvasLayoutInfo>(layoutInfo))
+        {
+            const auto& info = std::get<FancyZonesDataTypes::CanvasLayoutInfo>(layoutInfo);
+            return static_cast<int>(info.zones.size());
+        }
+        return 0;
+    };
+
+    // NumberOfZonesForEachCustomZoneSet
+    int i = 0;
+    for (const auto& [id, customZoneSetData] : customZones)
+    {
+        customZonesArray.get()[i] = getCustomZoneCount(customZoneSetData.info);
+        i++;
+    }
+
+    // ActiveZoneSetsList
+    std::wstring activeZoneSetInfo;
+    for (const auto& [id, device] : devices)
+    {
+        const FancyZonesDataTypes::ZoneSetLayoutType type = device.activeZoneSet.type;
+        if (!activeZoneSetInfo.empty())
+        {
+            activeZoneSetInfo += L"; ";
+        }
+        activeZoneSetInfo += L"type: " + FancyZonesDataTypes::TypeToString(type);
+
+        int zoneCount = -1;
+        if (type == FancyZonesDataTypes::ZoneSetLayoutType::Custom)
+        {
+            const auto& activeCustomZone = customZones.find(device.activeZoneSet.uuid);
+            if (activeCustomZone != customZones.end())
+            {
+                zoneCount = getCustomZoneCount(activeCustomZone->second.info);
+            }
+        }
+        else
+        {
+            zoneCount = device.zoneCount;
+        }
+
+        if (zoneCount != -1)
+        {
+            activeZoneSetInfo += L", zone count: " + std::to_wstring(zoneCount);
+        }
+        else
+        {
+            activeZoneSetInfo += L", custom zone data was deleted";
+        }
+    }
+
+    TraceLoggingWrite(
+        g_hProvider,
+        EventZoneSettingsChangedKey,
+        ProjectTelemetryPrivacyDataTag(ProjectTelemetryTag_ProductAndServicePerformance),
+        TraceLoggingKeyword(PROJECT_KEYWORD_MEASURE),
+        TraceLoggingInt32(appsHistorySize, AppsInHistoryCountKey),
+        TraceLoggingInt32(static_cast<int>(customZones.size()), CustomZoneSetCountKey),
+        TraceLoggingInt32Array(customZonesArray.get(), static_cast<int>(customZones.size()), NumberOfZonesForEachCustomZoneSetKey),
+        TraceLoggingInt32(static_cast<int>(devices.size()), ActiveZoneSetsCountKey),
+        TraceLoggingWideString(activeZoneSetInfo.c_str(), ActiveZoneSetsListKey),
+        TraceLoggingInt32(static_cast<int>(quickKeys.size()), LayoutUsingQuickKeyCountKey));
+}
+
+void Trace::FancyZones::EditorLaunched(int value) noexcept
+{
+    TraceLoggingWrite(
+        g_hProvider,
+        EventEditorLaunchKey,
+        ProjectTelemetryPrivacyDataTag(ProjectTelemetryTag_ProductAndServicePerformance),
+        TraceLoggingKeyword(PROJECT_KEYWORD_MEASURE),
+        TraceLoggingInt32(value, EditorLaunchValueKey));
+}
+
+// Log if an error occurs in FZ
+void Trace::FancyZones::Error(const DWORD errorCode, std::wstring errorMessage, std::wstring methodName) noexcept
+{
+    TraceLoggingWrite(
+        g_hProvider,
+        "FancyZones_Error",
+        ProjectTelemetryPrivacyDataTag(ProjectTelemetryTag_ProductAndServicePerformance),
+        TraceLoggingKeyword(PROJECT_KEYWORD_MEASURE),
+        TraceLoggingValue(methodName.c_str(), "MethodName"),
+        TraceLoggingValue(errorCode, "ErrorCode"),
+        TraceLoggingValue(errorMessage.c_str(), "ErrorMessage"));
+}
+
+void Trace::FancyZones::QuickLayoutSwitched(bool shortcutUsed) noexcept
+{
+    TraceLoggingWrite(
+        g_hProvider,
+        EventQuickLayoutSwitchKey,
+        ProjectTelemetryPrivacyDataTag(ProjectTelemetryTag_ProductAndServicePerformance),
+        TraceLoggingKeyword(PROJECT_KEYWORD_MEASURE),
+        TraceLoggingBoolean(shortcutUsed, QuickLayoutSwitchedWithShortcutUsed));
+}
+
+void Trace::SettingsTelemetry(const Settings& settings) noexcept
+{
+    const auto& editorHotkey = settings.editorHotkey;
+    std::wstring hotkeyStr = L"alt:" + std::to_wstring(editorHotkey.alt_pressed())
+        + L", ctrl:" + std::to_wstring(editorHotkey.ctrl_pressed())
+        + L", shift:" + std::to_wstring(editorHotkey.shift_pressed())
+        + L", win:" + std::to_wstring(editorHotkey.win_pressed())
+        + L", code:" + std::to_wstring(editorHotkey.get_code())
+        + L", keyFromCode:" + editorHotkey.get_key();
+
+    TraceLoggingWrite(
+        g_hProvider,
+        EventSettingsKey,
+        ProjectTelemetryPrivacyDataTag(ProjectTelemetryTag_ProductAndServicePerformance),
+        TraceLoggingKeyword(PROJECT_KEYWORD_MEASURE),
+        TraceLoggingBoolean(settings.shiftDrag, ShiftDragKey),
+        TraceLoggingBoolean(settings.mouseSwitch, MouseSwitchKey),
+        TraceLoggingBoolean(settings.displayChange_moveWindows, MoveWindowsOnDisplayChangeKey),
+        TraceLoggingBoolean(settings.zoneSetChange_flashZones, FlashZonesOnZoneSetChangeKey),
+        TraceLoggingBoolean(settings.zoneSetChange_moveWindows, MoveWindowsOnZoneSetChangeKey),
+        TraceLoggingBoolean(settings.overrideSnapHotkeys, OverrideSnapHotKeysKey),
+        TraceLoggingBoolean(settings.moveWindowAcrossMonitors, MoveWindowAcrossMonitorsKey),
+        TraceLoggingBoolean(settings.moveWindowsBasedOnPosition, MoveWindowsBasedOnPositionKey),
+        TraceLoggingBoolean(settings.appLastZone_moveWindows, MoveWindowsToLastZoneOnAppOpeningKey),
+        TraceLoggingBoolean(settings.openWindowOnActiveMonitor, OpenWindowOnActiveMonitorKey),
+        TraceLoggingBoolean(settings.restoreSize, RestoreSizeKey),
+        TraceLoggingBoolean(settings.quickLayoutSwitch, QuickLayoutSwitchKey),
+        TraceLoggingBoolean(settings.flashZonesOnQuickSwitch, FlashZonesOnQuickSwitchKey),
+        TraceLoggingBoolean(settings.use_cursorpos_editor_startupscreen, UseCursorPosOnEditorStartupKey),
+        TraceLoggingBoolean(settings.showZonesOnAllMonitors, ShowZonesOnAllMonitorsKey),
+        TraceLoggingBoolean(settings.spanZonesAcrossMonitors, SpanZonesAcrossMonitorsKey),
+        TraceLoggingBoolean(settings.makeDraggedWindowTransparent, MakeDraggedWindowTransparentKey),
+        TraceLoggingWideString(settings.zoneColor.c_str(), ZoneColorKey),
+        TraceLoggingWideString(settings.zoneBorderColor.c_str(), ZoneBorderColorKey),
+        TraceLoggingWideString(settings.zoneHighlightColor.c_str(), ZoneHighlightColorKey),
+        TraceLoggingInt32(settings.zoneHighlightOpacity, ZoneHighlightOpacityKey),
+        TraceLoggingInt32((int)settings.overlappingZonesAlgorithm, OverlappingZonesAlgorithmKey),
+        TraceLoggingWideString(hotkeyStr.c_str(), HotkeyKey),
+        TraceLoggingInt32(static_cast<int>(settings.excludedAppsArray.size()), ExcludedAppsCountKey));
+}
+
+void Trace::VirtualDesktopChanged() noexcept
+{
+    TraceLoggingWrite(
+        g_hProvider,
+        EventDesktopChangedKey,
+        ProjectTelemetryPrivacyDataTag(ProjectTelemetryTag_ProductAndServicePerformance),
+        TraceLoggingKeyword(PROJECT_KEYWORD_MEASURE));
+}
+
+void Trace::ZoneWindow::KeyUp(WPARAM wParam) noexcept
+{
+    TraceLoggingWrite(
+        g_hProvider,
+        EventZoneWindowKeyUpKey,
+        ProjectTelemetryPrivacyDataTag(ProjectTelemetryTag_ProductAndServicePerformance),
+        TraceLoggingKeyword(PROJECT_KEYWORD_MEASURE),
+        TraceLoggingValue(wParam, KeyboardValueKey));
+}
+
+void Trace::ZoneWindow::MoveSizeEnd(_In_opt_ winrt::com_ptr<IZoneSet> activeSet) noexcept
+{
+    auto const zoneInfo = GetZoneSetInfo(activeSet);
+    TraceLoggingWrite(
+        g_hProvider,
+        EventMoveSizeEndKey,
+        ProjectTelemetryPrivacyDataTag(ProjectTelemetryTag_ProductAndServicePerformance),
+        TraceLoggingKeyword(PROJECT_KEYWORD_MEASURE),
+        TraceLoggingValue(reinterpret_cast<void*>(activeSet.get()), ActiveSetKey),
+        TraceLoggingValue(zoneInfo.NumberOfZones, NumberOfZonesKey),
+        TraceLoggingValue(zoneInfo.NumberOfWindows, NumberOfWindowsKey));
+}
+
+void Trace::ZoneWindow::CycleActiveZoneSet(_In_opt_ winrt::com_ptr<IZoneSet> activeSet, InputMode mode) noexcept
+{
+    auto const zoneInfo = GetZoneSetInfo(activeSet);
+    TraceLoggingWrite(
+        g_hProvider,
+        EventCycleActiveZoneSetKey,
+        ProjectTelemetryPrivacyDataTag(ProjectTelemetryTag_ProductAndServicePerformance),
+        TraceLoggingKeyword(PROJECT_KEYWORD_MEASURE),
+        TraceLoggingValue(reinterpret_cast<void*>(activeSet.get()), ActiveSetKey),
+        TraceLoggingValue(zoneInfo.NumberOfZones, NumberOfZonesKey),
+        TraceLoggingValue(zoneInfo.NumberOfWindows, NumberOfWindowsKey),
+        TraceLoggingValue(static_cast<int>(mode), InputModeKey));
+}

src/modules/fancyzones/FancyZonesLib/trace.h

@@ -0,0 +1,39 @@
+#pragma once
+
+struct Settings;
+interface IZoneSet;
+
+class Trace
+{
+public:
+    static void RegisterProvider() noexcept;
+    static void UnregisterProvider() noexcept;
+
+    class FancyZones
+    {
+    public:
+        static void EnableFancyZones(bool enabled) noexcept;
+        static void OnKeyDown(DWORD vkCode, bool win, bool control, bool inMoveSize) noexcept;
+        static void DataChanged() noexcept;
+        static void EditorLaunched(int value) noexcept;
+        static void Error(const DWORD errorCode, std::wstring errorMessage, std::wstring methodName) noexcept;
+        static void QuickLayoutSwitched(bool shortcutUsed) noexcept;
+    };
+
+    static void SettingsTelemetry(const Settings& settings) noexcept;
+    static void VirtualDesktopChanged() noexcept;
+
+    class ZoneWindow
+    {
+    public:
+        enum class InputMode
+        {
+            Keyboard,
+            Mouse
+        };
+
+        static void KeyUp(WPARAM wparam) noexcept;
+        static void MoveSizeEnd(_In_opt_ winrt::com_ptr<IZoneSet> activeSet) noexcept;
+        static void CycleActiveZoneSet(_In_opt_ winrt::com_ptr<IZoneSet> activeSet, InputMode mode) noexcept;
+    };
+};

src/modules/fancyzones/FancyZonesLib/util.cpp

@@ -0,0 +1,865 @@
+#include "pch.h"
+#include "util.h"
+#include "Settings.h"
+
+#include <common/display/dpi_aware.h>
+#include <common/utils/process_path.h>
+#include <common/utils/window.h>
+
+#include <array>
+#include <sstream>
+#include <complex>
+#include <wil/Resource.h>
+
+#include <fancyzones/FancyZonesLib/FancyZonesDataTypes.h>
+
+// Non-Localizable strings
+namespace NonLocalizable
+{
+    const wchar_t PowerToysAppPowerLauncher[] = L"POWERLAUNCHER.EXE";
+    const wchar_t PowerToysAppFZEditor[] = L"FANCYZONESEDITOR.EXE";
+}
+
+bool find_app_name_in_path(const std::wstring& where, const std::vector<std::wstring>& what)
+{
+    for (const auto& row : what)
+    {
+        const auto pos = where.rfind(row);
+        const auto last_slash = where.rfind('\\');
+        //Check that row occurs in where, and its last occurrence contains in itself the first character after the last backslash.
+        if (pos != std::wstring::npos && pos <= last_slash + 1 && pos + row.length() > last_slash)
+        {
+            return true;
+        }
+    }
+    return false;
+}
+namespace
+{
+    bool IsZonableByProcessPath(const std::wstring& processPath, const std::vector<std::wstring>& excludedApps)
+    {
+        // Filter out user specified apps
+        CharUpperBuffW(const_cast<std::wstring&>(processPath).data(), (DWORD)processPath.length());
+        if (find_app_name_in_path(processPath, excludedApps))
+        {
+            return false;
+        }
+        if (find_app_name_in_path(processPath, { NonLocalizable::PowerToysAppPowerLauncher }))
+        {
+            return false;
+        }
+        if (find_app_name_in_path(processPath, { NonLocalizable::PowerToysAppFZEditor }))
+        {
+            return false;
+        }
+        return true;
+    }
+}
+
+namespace FancyZonesUtils
+{
+    std::wstring TrimDeviceId(const std::wstring& deviceId)
+    {
+        // We're interested in the unique part between the first and last #'s
+        // Example input: \\?\DISPLAY#DELA026#5&10a58c63&0&UID16777488#{e6f07b5f-ee97-4a90-b076-33f57bf4eaa7}
+        // Example output: DELA026#5&10a58c63&0&UID16777488
+        static const std::wstring defaultDeviceId = L"FallbackDevice";
+        if (deviceId.empty())
+        {
+            return defaultDeviceId;
+        }
+
+        size_t start = deviceId.find(L'#');
+        size_t end = deviceId.rfind(L'#');
+        if (start != std::wstring::npos && end != std::wstring::npos && start != end)
+        {
+            size_t size = end - (start + 1);
+            return deviceId.substr(start + 1, size);
+        }
+        else
+        {
+            return defaultDeviceId;
+        }
+    }
+
+    std::optional<FancyZonesDataTypes::DeviceIdData> ParseDeviceId(const std::wstring& str)
+    {
+        FancyZonesDataTypes::DeviceIdData data;
+
+        std::wstring temp;
+        std::wstringstream wss(str);
+
+        /*
+        Important fix for device info that contains a '_' in the name:
+        1. first search for '#'
+        2. Then split the remaining string by '_'
+        */
+
+        // Step 1: parse the name until the #, then to the '_'
+        if (str.find(L'#') != std::string::npos)
+        {
+            std::getline(wss, temp, L'#');
+
+            data.deviceName = temp;
+
+            if (!std::getline(wss, temp, L'_'))
+            {
+                return std::nullopt;
+            }
+
+            data.deviceName += L"#" + temp;
+        }
+        else if (std::getline(wss, temp, L'_') && !temp.empty())
+        {
+            data.deviceName = temp;
+        }
+        else
+        {
+            return std::nullopt;
+        }
+
+        // Step 2: parse the rest of the id
+        std::vector<std::wstring> parts;
+        while (std::getline(wss, temp, L'_'))
+        {
+            parts.push_back(temp);
+        }
+
+        if (parts.size() != 3 && parts.size() != 4)
+        {
+            return std::nullopt;
+        }
+
+        /*
+        Refer to ZoneWindowUtils::GenerateUniqueId parts contain:
+        1. monitor id [string]
+        2. width of device [int]
+        3. height of device [int]
+        4. virtual desktop id (GUID) [string]
+        */
+        try
+        {
+            for (const auto& c : parts[0])
+            {
+                std::stoi(std::wstring(&c));
+            }
+
+            for (const auto& c : parts[1])
+            {
+                std::stoi(std::wstring(&c));
+            }
+
+            data.width = std::stoi(parts[0]);
+            data.height = std::stoi(parts[1]);
+        }
+        catch (const std::exception&)
+        {
+            return std::nullopt;
+        }
+
+        if (!SUCCEEDED(CLSIDFromString(parts[2].c_str(), &data.virtualDesktopId)))
+        {
+            return std::nullopt;
+        }
+
+        if (parts.size() == 4)
+        {
+            data.monitorId = parts[3]; //could be empty
+        }
+
+        return data;
+    }
+
+    typedef BOOL(WINAPI* GetDpiForMonitorInternalFunc)(HMONITOR, UINT, UINT*, UINT*);
+
+    std::wstring GetDisplayDeviceId(const std::wstring& device, std::unordered_map<std::wstring, DWORD>& displayDeviceIdxMap)
+    {
+        DISPLAY_DEVICE displayDevice{ .cb = sizeof(displayDevice) };
+        std::wstring deviceId;
+        while (EnumDisplayDevicesW(device.c_str(), displayDeviceIdxMap[device], &displayDevice, EDD_GET_DEVICE_INTERFACE_NAME))
+        {
+            ++displayDeviceIdxMap[device];
+
+            // Only take active monitors (presented as being "on" by the respective GDI view) and monitors that don't
+            // represent a pseudo device used to mirror application drawing.
+            if (WI_IsFlagSet(displayDevice.StateFlags, DISPLAY_DEVICE_ACTIVE) &&
+                WI_IsFlagClear(displayDevice.StateFlags, DISPLAY_DEVICE_MIRRORING_DRIVER))
+            {
+                deviceId = displayDevice.DeviceID;
+                break;
+            }
+        }
+
+        if (deviceId.empty())
+        {
+            deviceId = GetSystemMetrics(SM_REMOTESESSION) ?
+                           L"\\\\?\\DISPLAY#REMOTEDISPLAY#" :
+                           L"\\\\?\\DISPLAY#LOCALDISPLAY#";
+        }
+
+        return deviceId;
+    }
+
+    UINT GetDpiForMonitor(HMONITOR monitor) noexcept
+    {
+        UINT dpi{};
+        if (wil::unique_hmodule user32{ LoadLibrary(L"user32.dll") })
+        {
+            if (auto func = reinterpret_cast<GetDpiForMonitorInternalFunc>(GetProcAddress(user32.get(), "GetDpiForMonitorInternal")))
+            {
+                func(monitor, 0, &dpi, &dpi);
+            }
+        }
+
+        if (dpi == 0)
+        {
+            if (wil::unique_hdc hdc{ GetDC(nullptr) })
+            {
+                dpi = GetDeviceCaps(hdc.get(), LOGPIXELSX);
+            }
+        }
+
+        return (dpi == 0) ? DPIAware::DEFAULT_DPI : dpi;
+    }
+
+    void OrderMonitors(std::vector<std::pair<HMONITOR, RECT>>& monitorInfo)
+    {
+        const size_t nMonitors = monitorInfo.size();
+        // blocking[i][j] - whether monitor i blocks monitor j in the ordering, i.e. monitor i should go before monitor j
+        std::vector<std::vector<bool>> blocking(nMonitors, std::vector<bool>(nMonitors, false));
+
+        // blockingCount[j] - the number of monitors which block monitor j
+        std::vector<size_t> blockingCount(nMonitors, 0);
+
+        for (size_t i = 0; i < nMonitors; i++)
+        {
+            RECT rectI = monitorInfo[i].second;
+            for (size_t j = 0; j < nMonitors; j++)
+            {
+                RECT rectJ = monitorInfo[j].second;
+                blocking[i][j] = rectI.top < rectJ.bottom && rectI.left < rectJ.right && i != j;
+                if (blocking[i][j])
+                {
+                    blockingCount[j]++;
+                }
+            }
+        }
+
+        // used[i] - whether the sorting algorithm has used monitor i so far
+        std::vector<bool> used(nMonitors, false);
+
+        // the sorted sequence of monitors
+        std::vector<std::pair<HMONITOR, RECT>> sortedMonitorInfo;
+
+        for (size_t iteration = 0; iteration < nMonitors; iteration++)
+        {
+            // Indices of candidates to become the next monitor in the sequence
+            std::vector<size_t> candidates;
+
+            // First, find indices of all unblocked monitors
+            for (size_t i = 0; i < nMonitors; i++)
+            {
+                if (blockingCount[i] == 0 && !used[i])
+                {
+                    candidates.push_back(i);
+                }
+            }
+
+            // In the unlikely event that there are no unblocked monitors, declare all unused monitors as candidates.
+            if (candidates.empty())
+            {
+                for (size_t i = 0; i < nMonitors; i++)
+                {
+                    if (!used[i])
+                    {
+                        candidates.push_back(i);
+                    }
+                }
+            }
+
+            // Pick the lexicographically smallest monitor as the next one
+            size_t smallest = candidates[0];
+            for (size_t j = 1; j < candidates.size(); j++)
+            {
+                size_t current = candidates[j];
+
+                // Compare (top, left) lexicographically
+                if (std::tie(monitorInfo[current].second.top, monitorInfo[current].second.left) <
+                    std::tie(monitorInfo[smallest].second.top, monitorInfo[smallest].second.left))
+                {
+                    smallest = current;
+                }
+            }
+
+            used[smallest] = true;
+            sortedMonitorInfo.push_back(monitorInfo[smallest]);
+            for (size_t i = 0; i < nMonitors; i++)
+            {
+                if (blocking[smallest][i])
+                {
+                    blockingCount[i]--;
+                }
+            }
+        }
+
+        monitorInfo = std::move(sortedMonitorInfo);
+    }
+
+    BOOL CALLBACK saveDisplayToVector(HMONITOR monitor, HDC hdc, LPRECT rect, LPARAM data)
+    {
+        reinterpret_cast<std::vector<HMONITOR>*>(data)->emplace_back(monitor);
+        return true;
+    }
+
+    bool allMonitorsHaveSameDpiScaling()
+    {
+        std::vector<HMONITOR> monitors;
+        EnumDisplayMonitors(NULL, NULL, saveDisplayToVector, reinterpret_cast<LPARAM>(&monitors));
+
+        if (monitors.size() < 2)
+        {
+            return true;
+        }
+
+        UINT firstMonitorDpiX;
+        UINT firstMonitorDpiY;
+
+        if (S_OK != GetDpiForMonitor(monitors[0], MDT_EFFECTIVE_DPI, &firstMonitorDpiX, &firstMonitorDpiY))
+        {
+            return false;
+        }
+
+        for (int i = 1; i < monitors.size(); i++)
+        {
+            UINT iteratedMonitorDpiX;
+            UINT iteratedMonitorDpiY;
+
+            if (S_OK != GetDpiForMonitor(monitors[i], MDT_EFFECTIVE_DPI, &iteratedMonitorDpiX, &iteratedMonitorDpiY) ||
+                iteratedMonitorDpiX != firstMonitorDpiX)
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    void ScreenToWorkAreaCoords(HWND window, RECT& rect)
+    {
+        // First, find the correct monitor. The monitor cannot be found using the given rect itself, we must first
+        // translate it to relative workspace coordinates.
+        HMONITOR monitor = MonitorFromRect(&rect, MONITOR_DEFAULTTOPRIMARY);
+        MONITORINFOEXW monitorInfo{ sizeof(MONITORINFOEXW) };
+        GetMonitorInfoW(monitor, &monitorInfo);
+
+        auto xOffset = monitorInfo.rcWork.left - monitorInfo.rcMonitor.left;
+        auto yOffset = monitorInfo.rcWork.top - monitorInfo.rcMonitor.top;
+
+        auto referenceRect = rect;
+
+        referenceRect.left -= xOffset;
+        referenceRect.right -= xOffset;
+        referenceRect.top -= yOffset;
+        referenceRect.bottom -= yOffset;
+
+        // Now, this rect should be used to determine the monitor and thus taskbar size. This fixes
+        // scenarios where the zone lies approximately between two monitors, and the taskbar is on the left.
+        monitor = MonitorFromRect(&referenceRect, MONITOR_DEFAULTTOPRIMARY);
+        GetMonitorInfoW(monitor, &monitorInfo);
+
+        xOffset = monitorInfo.rcWork.left - monitorInfo.rcMonitor.left;
+        yOffset = monitorInfo.rcWork.top - monitorInfo.rcMonitor.top;
+
+        rect.left -= xOffset;
+        rect.right -= xOffset;
+        rect.top -= yOffset;
+        rect.bottom -= yOffset;
+
+        const auto level = DPIAware::GetAwarenessLevel(GetWindowDpiAwarenessContext(window));
+        const bool accountForUnawareness = level < DPIAware::PER_MONITOR_AWARE;
+
+        if (accountForUnawareness && !allMonitorsHaveSameDpiScaling())
+        {
+            rect.left = max(monitorInfo.rcMonitor.left, rect.left);
+            rect.right = min(monitorInfo.rcMonitor.right - xOffset, rect.right);
+            rect.top = max(monitorInfo.rcMonitor.top, rect.top);
+            rect.bottom = min(monitorInfo.rcMonitor.bottom - yOffset, rect.bottom);
+        }
+    }
+
+    void SizeWindowToRect(HWND window, RECT rect) noexcept
+    {
+        WINDOWPLACEMENT placement{};
+        ::GetWindowPlacement(window, &placement);
+
+        // Wait if SW_SHOWMINIMIZED would be removed from window (Issue #1685)
+        for (int i = 0; i < 5 && (placement.showCmd == SW_SHOWMINIMIZED); ++i)
+        {
+            std::this_thread::sleep_for(std::chrono::milliseconds(100));
+            ::GetWindowPlacement(window, &placement);
+        }
+
+        // Do not restore minimized windows. We change their placement though so they restore to the correct zone.
+        if ((placement.showCmd != SW_SHOWMINIMIZED) &&
+            (placement.showCmd != SW_MINIMIZE))
+        {
+            placement.showCmd = SW_RESTORE;
+        }
+
+        // Remove maximized show command to make sure window is moved to the correct zone.
+        if (placement.showCmd == SW_SHOWMAXIMIZED)
+        {
+            placement.showCmd = SW_RESTORE;
+            placement.flags &= ~WPF_RESTORETOMAXIMIZED;
+        }
+
+        ScreenToWorkAreaCoords(window, rect);
+
+        placement.rcNormalPosition = rect;
+        placement.flags |= WPF_ASYNCWINDOWPLACEMENT;
+
+        ::SetWindowPlacement(window, &placement);
+        // Do it again, allowing Windows to resize the window and set correct scaling
+        // This fixes Issue #365
+        ::SetWindowPlacement(window, &placement);
+    }
+
+    bool HasNoVisibleOwner(HWND window) noexcept
+    {
+        auto owner = GetWindow(window, GW_OWNER);
+        if (owner == nullptr)
+        {
+            return true; // There is no owner at all
+        }
+        if (!IsWindowVisible(owner))
+        {
+            return true; // Owner is invisible
+        }
+        RECT rect;
+        if (!GetWindowRect(owner, &rect))
+        {
+            return false; // Could not get the rect, return true (and filter out the window) just in case
+        }
+        // It is enough that the window is zero-sized in one dimension only.
+        return rect.top == rect.bottom || rect.left == rect.right;
+    }
+
+    bool IsStandardWindow(HWND window)
+    {
+        if (GetAncestor(window, GA_ROOT) != window || !IsWindowVisible(window))
+        {
+            return false;
+        }
+        auto style = GetWindowLong(window, GWL_STYLE);
+        auto exStyle = GetWindowLong(window, GWL_EXSTYLE);
+        // WS_POPUP need to have a border or minimize/maximize buttons,
+        // otherwise the window is "not interesting"
+        if ((style & WS_POPUP) == WS_POPUP &&
+            (style & WS_THICKFRAME) == 0 &&
+            (style & WS_MINIMIZEBOX) == 0 &&
+            (style & WS_MAXIMIZEBOX) == 0)
+        {
+            return false;
+        }
+        if ((style & WS_CHILD) == WS_CHILD ||
+            (style & WS_DISABLED) == WS_DISABLED ||
+            (exStyle & WS_EX_TOOLWINDOW) == WS_EX_TOOLWINDOW ||
+            (exStyle & WS_EX_NOACTIVATE) == WS_EX_NOACTIVATE)
+        {
+            return false;
+        }
+        std::array<char, 256> class_name;
+        GetClassNameA(window, class_name.data(), static_cast<int>(class_name.size()));
+        if (is_system_window(window, class_name.data()))
+        {
+            return false;
+        }
+        auto process_path = get_process_path(window);
+        // Check for Cortana:
+        if (strcmp(class_name.data(), "Windows.UI.Core.CoreWindow") == 0 &&
+            process_path.ends_with(L"SearchUI.exe"))
+        {
+            return false;
+        }
+
+        return true;
+    }
+
+    bool IsCandidateForLastKnownZone(HWND window, const std::vector<std::wstring>& excludedApps) noexcept
+    {
+        auto zonable = IsStandardWindow(window) && HasNoVisibleOwner(window);
+        if (!zonable)
+        {
+            return false;
+        }
+
+        return IsZonableByProcessPath(get_process_path(window), excludedApps);
+    }
+
+    bool IsCandidateForZoning(HWND window, const std::vector<std::wstring>& excludedApps) noexcept
+    {
+        if (!IsStandardWindow(window))
+        {
+            return false;
+        }
+
+        return IsZonableByProcessPath(get_process_path(window), excludedApps);
+    }
+
+    bool IsWindowMaximized(HWND window) noexcept
+    {
+        WINDOWPLACEMENT placement{};
+        if (GetWindowPlacement(window, &placement) &&
+            placement.showCmd == SW_SHOWMAXIMIZED)
+        {
+            return true;
+        }
+        return false;
+    }
+
+    void SaveWindowSizeAndOrigin(HWND window) noexcept
+    {
+        HANDLE handle = GetPropW(window, ZonedWindowProperties::PropertyRestoreSizeID);
+        if (handle)
+        {
+            // Size already set, skip
+            return;
+        }
+
+        RECT rect;
+        if (GetWindowRect(window, &rect))
+        {
+            int width = rect.right - rect.left;
+            int height = rect.bottom - rect.top;
+            int originX = rect.left;
+            int originY = rect.top;
+
+            DPIAware::InverseConvert(MonitorFromWindow(window, MONITOR_DEFAULTTONULL), width, height);
+            DPIAware::InverseConvert(MonitorFromWindow(window, MONITOR_DEFAULTTONULL), originX, originY);
+
+            std::array<int, 2> windowSizeData = { width, height };
+            std::array<int, 2> windowOriginData = { originX, originY };
+            HANDLE rawData;
+            memcpy(&rawData, windowSizeData.data(), sizeof rawData);
+            SetPropW(window, ZonedWindowProperties::PropertyRestoreSizeID, rawData);
+            memcpy(&rawData, windowOriginData.data(), sizeof rawData);
+            SetPropW(window, ZonedWindowProperties::PropertyRestoreOriginID, rawData);
+        }
+    }
+
+    void RestoreWindowSize(HWND window) noexcept
+    {
+        auto windowSizeData = GetPropW(window, ZonedWindowProperties::PropertyRestoreSizeID);
+        if (windowSizeData)
+        {
+            std::array<int, 2> windowSize;
+            memcpy(windowSize.data(), &windowSizeData, sizeof windowSize);
+
+            // {width, height}
+            DPIAware::Convert(MonitorFromWindow(window, MONITOR_DEFAULTTONULL), windowSize[0], windowSize[1]);
+
+            RECT rect;
+            if (GetWindowRect(window, &rect))
+            {
+                rect.right = rect.left + windowSize[0];
+                rect.bottom = rect.top + windowSize[1];
+                SizeWindowToRect(window, rect);
+            }
+
+            ::RemoveProp(window, ZonedWindowProperties::PropertyRestoreSizeID);
+        }
+    }
+
+    void RestoreWindowOrigin(HWND window) noexcept
+    {
+        auto windowOriginData = GetPropW(window, ZonedWindowProperties::PropertyRestoreOriginID);
+        if (windowOriginData)
+        {
+            std::array<int, 2> windowOrigin;
+            memcpy(windowOrigin.data(), &windowOriginData, sizeof windowOrigin);
+
+            // {width, height}
+            DPIAware::Convert(MonitorFromWindow(window, MONITOR_DEFAULTTONULL), windowOrigin[0], windowOrigin[1]);
+
+            RECT rect;
+            if (GetWindowRect(window, &rect))
+            {
+                int xOffset = windowOrigin[0] - rect.left;
+                int yOffset = windowOrigin[1] - rect.top;
+
+                rect.left += xOffset;
+                rect.right += xOffset;
+                rect.top += yOffset;
+                rect.bottom += yOffset;
+                SizeWindowToRect(window, rect);
+            }
+
+            ::RemoveProp(window, ZonedWindowProperties::PropertyRestoreOriginID);
+        }
+    }
+
+    bool IsValidGuid(const std::wstring& str)
+    {
+        GUID id;
+        return SUCCEEDED(CLSIDFromString(str.c_str(), &id));
+    }
+
+    bool IsValidDeviceId(const std::wstring& str)
+    {
+        std::wstring monitorName;
+        std::wstring temp;
+        std::vector<std::wstring> parts;
+        std::wstringstream wss(str);
+
+        /*
+        Important fix for device info that contains a '_' in the name:
+        1. first search for '#'
+        2. Then split the remaining string by '_'
+        */
+
+        // Step 1: parse the name until the #, then to the '_'
+        if (str.find(L'#') != std::string::npos)
+        {
+            std::getline(wss, temp, L'#');
+
+            monitorName = temp;
+
+            if (!std::getline(wss, temp, L'_'))
+            {
+                return false;
+            }
+
+            monitorName += L"#" + temp;
+            parts.push_back(monitorName);
+        }
+
+        // Step 2: parse the rest of the id
+        while (std::getline(wss, temp, L'_'))
+        {
+            parts.push_back(temp);
+        }
+
+        if (parts.size() != 4)
+        {
+            return false;
+        }
+
+        /*
+        Refer to ZoneWindowUtils::GenerateUniqueId parts contain:
+        1. monitor id [string]
+        2. width of device [int]
+        3. height of device [int]
+        4. virtual desktop id (GUID) [string]
+    */
+        try
+        {
+            //check if resolution contain only digits
+            for (const auto& c : parts[1])
+            {
+                std::stoi(std::wstring(&c));
+            }
+            for (const auto& c : parts[2])
+            {
+                std::stoi(std::wstring(&c));
+            }
+        }
+        catch (const std::exception&)
+        {
+            return false;
+        }
+
+        if (!IsValidGuid(parts[3]) || parts[0].empty())
+        {
+            return false;
+        }
+
+        return true;
+    }
+
+    std::wstring GenerateUniqueId(HMONITOR monitor, const std::wstring& deviceId, const std::wstring& virtualDesktopId)
+    {
+        MONITORINFOEXW mi;
+        mi.cbSize = sizeof(mi);
+        if (!virtualDesktopId.empty() && GetMonitorInfo(monitor, &mi))
+        {
+            Rect const monitorRect(mi.rcMonitor);
+            // Unique identifier format: <parsed-device-id>_<width>_<height>_<virtual-desktop-id>
+            return TrimDeviceId(deviceId) +
+                   L'_' +
+                   std::to_wstring(monitorRect.width()) +
+                   L'_' +
+                   std::to_wstring(monitorRect.height()) +
+                   L'_' +
+                   virtualDesktopId;
+        }
+        return {};
+    }
+
+    std::wstring GenerateUniqueIdAllMonitorsArea(const std::wstring& virtualDesktopId)
+    {
+        std::wstring result{ ZonedWindowProperties::MultiMonitorDeviceID };
+
+        RECT combinedResolution = GetAllMonitorsCombinedRect<&MONITORINFO::rcMonitor>();
+
+        result += L'_';
+        result += std::to_wstring(combinedResolution.right - combinedResolution.left);
+        result += L'_';
+        result += std::to_wstring(combinedResolution.bottom - combinedResolution.top);
+        result += L'_';
+        result += virtualDesktopId;
+
+        return result;
+    }
+
+    size_t ChooseNextZoneByPosition(DWORD vkCode, RECT windowRect, const std::vector<RECT>& zoneRects) noexcept
+    {
+        using complex = std::complex<double>;
+        const size_t invalidResult = zoneRects.size();
+        const double inf = 1e100;
+        const double eccentricity = 2.0;
+
+        auto rectCenter = [](RECT rect) {
+            return complex{
+                0.5 * rect.left + 0.5 * rect.right,
+                0.5 * rect.top + 0.5 * rect.bottom
+            };
+        };
+
+        auto distance = [&](complex arrowDirection, complex zoneDirection) {
+            double result = inf;
+
+            try
+            {
+                double scalarProduct = (arrowDirection * conj(zoneDirection)).real();
+                if (scalarProduct <= 0.0)
+                {
+                    return inf;
+                }
+
+                // no need to divide by abs(arrowDirection) because it's = 1
+                double cosAngle = scalarProduct / abs(zoneDirection);
+                double tanAngle = abs(tan(acos(cosAngle)));
+
+                if (tanAngle > 10)
+                {
+                    // The angle is too wide
+                    return inf;
+                }
+
+                // find the intersection with the ellipse with given eccentricity and major axis along arrowDirection
+                double intersectY = 2 * eccentricity / (1.0 + eccentricity * eccentricity * tanAngle * tanAngle);
+                double distanceEstimate = scalarProduct / intersectY;
+
+                if (std::isfinite(distanceEstimate))
+                {
+                    result = distanceEstimate;
+                }
+            }
+            catch (...)
+            {
+            }
+
+            return result;
+        };
+        std::vector<std::pair<size_t, complex>> candidateCenters;
+        for (size_t i = 0; i < zoneRects.size(); i++)
+        {
+            auto center = rectCenter(zoneRects[i]);
+
+            // Offset the zone slightly, to differentiate in case there are overlapping zones
+            center += 0.001 * (i + 1);
+
+            candidateCenters.emplace_back(i, center);
+        }
+
+        complex directionVector, windowCenter = rectCenter(windowRect);
+
+        switch (vkCode)
+        {
+        case VK_UP:
+            directionVector = { 0.0, -1.0 };
+            break;
+        case VK_DOWN:
+            directionVector = { 0.0, 1.0 };
+            break;
+        case VK_LEFT:
+            directionVector = { -1.0, 0.0 };
+            break;
+        case VK_RIGHT:
+            directionVector = { 1.0, 0.0 };
+            break;
+        default:
+            return invalidResult;
+        }
+
+        size_t closestIdx = invalidResult;
+        double smallestDistance = inf;
+
+        for (auto [zoneIdx, zoneCenter] : candidateCenters)
+        {
+            double dist = distance(directionVector, zoneCenter - windowCenter);
+            if (dist < smallestDistance)
+            {
+                smallestDistance = dist;
+                closestIdx = zoneIdx;
+            }
+        }
+
+        return closestIdx;
+    }
+
+    RECT PrepareRectForCycling(RECT windowRect, RECT zoneWindowRect, DWORD vkCode) noexcept
+    {
+        LONG deltaX = 0, deltaY = 0;
+        switch (vkCode)
+        {
+        case VK_UP:
+            deltaY = zoneWindowRect.bottom - zoneWindowRect.top;
+            break;
+        case VK_DOWN:
+            deltaY = zoneWindowRect.top - zoneWindowRect.bottom;
+            break;
+        case VK_LEFT:
+            deltaX = zoneWindowRect.right - zoneWindowRect.left;
+            break;
+        case VK_RIGHT:
+            deltaX = zoneWindowRect.left - zoneWindowRect.right;
+        }
+
+        windowRect.left += deltaX;
+        windowRect.right += deltaX;
+        windowRect.top += deltaY;
+        windowRect.bottom += deltaY;
+
+        return windowRect;
+    }
+
+    bool IsProcessOfWindowElevated(HWND window)
+    {
+        DWORD pid = 0;
+        GetWindowThreadProcessId(window, &pid);
+        if (!pid)
+        {
+            return false;
+        }
+
+        wil::unique_handle hProcess{ OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION,
+                                                 FALSE,
+                                                 pid) };
+
+        wil::unique_handle token;
+        bool elevated = false;
+
+        if (OpenProcessToken(hProcess.get(), TOKEN_QUERY, &token))
+        {
+            TOKEN_ELEVATION elevation;
+            DWORD size;
+            if (GetTokenInformation(token.get(), TokenElevation, &elevation, sizeof(elevation), &size))
+            {
+                return elevation.TokenIsElevated != 0;
+            }
+        }
+        return false;
+    }
+
+}

src/modules/fancyzones/FancyZonesLib/util.h

@@ -0,0 +1,219 @@
+#pragma once
+
+#include "gdiplus.h"
+#include <common/utils/string_utils.h>
+
+namespace FancyZonesDataTypes
+{
+    struct DeviceIdData;
+}
+
+namespace FancyZonesUtils
+{
+    struct Rect
+    {
+        Rect() {}
+
+        Rect(RECT rect) :
+            m_rect(rect)
+        {
+        }
+
+        Rect(RECT rect, UINT dpi) :
+            m_rect(rect)
+        {
+            m_rect.right = m_rect.left + MulDiv(m_rect.right - m_rect.left, dpi, 96);
+            m_rect.bottom = m_rect.top + MulDiv(m_rect.bottom - m_rect.top, dpi, 96);
+        }
+
+        int x() const { return m_rect.left; }
+        int y() const { return m_rect.top; }
+        int width() const { return m_rect.right - m_rect.left; }
+        int height() const { return m_rect.bottom - m_rect.top; }
+        int left() const { return m_rect.left; }
+        int top() const { return m_rect.top; }
+        int right() const { return m_rect.right; }
+        int bottom() const { return m_rect.bottom; }
+        int aspectRatio() const { return MulDiv(m_rect.bottom - m_rect.top, 100, m_rect.right - m_rect.left); }
+
+    private:
+        RECT m_rect{};
+    };
+
+    inline void MakeWindowTransparent(HWND window)
+    {
+        int const pos = -GetSystemMetrics(SM_CXVIRTUALSCREEN) - 8;
+        if (wil::unique_hrgn hrgn{ CreateRectRgn(pos, 0, (pos + 1), 1) })
+        {
+            DWM_BLURBEHIND bh = { DWM_BB_ENABLE | DWM_BB_BLURREGION, TRUE, hrgn.get(), FALSE };
+            DwmEnableBlurBehindWindow(window, &bh);
+        }
+    }
+
+    inline void InitRGB(_Out_ RGBQUAD* quad, BYTE alpha, COLORREF color)
+    {
+        ZeroMemory(quad, sizeof(*quad));
+        quad->rgbReserved = alpha;
+        quad->rgbRed = GetRValue(color) * alpha / 255;
+        quad->rgbGreen = GetGValue(color) * alpha / 255;
+        quad->rgbBlue = GetBValue(color) * alpha / 255;
+    }
+
+    inline void FillRectARGB(wil::unique_hdc& hdc, RECT const* prcFill, BYTE alpha, COLORREF color, bool blendAlpha)
+    {
+        BITMAPINFO bi;
+        ZeroMemory(&bi, sizeof(bi));
+        bi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
+        bi.bmiHeader.biWidth = 1;
+        bi.bmiHeader.biHeight = 1;
+        bi.bmiHeader.biPlanes = 1;
+        bi.bmiHeader.biBitCount = 32;
+        bi.bmiHeader.biCompression = BI_RGB;
+
+        RECT fillRect;
+        CopyRect(&fillRect, prcFill);
+
+        RGBQUAD bitmapBits;
+        InitRGB(&bitmapBits, alpha, color);
+        StretchDIBits(
+            hdc.get(),
+            fillRect.left,
+            fillRect.top,
+            fillRect.right - fillRect.left,
+            fillRect.bottom - fillRect.top,
+            0,
+            0,
+            1,
+            1,
+            &bitmapBits,
+            &bi,
+            DIB_RGB_COLORS,
+            SRCCOPY);
+    }
+
+    inline COLORREF HexToRGB(std::wstring_view hex, const COLORREF fallbackColor = RGB(255, 255, 255))
+    {
+        hex = left_trim<wchar_t>(trim<wchar_t>(hex), L"#");
+
+        try
+        {
+            const long long tmp = std::stoll(hex.data(), nullptr, 16);
+            const BYTE nR = static_cast<BYTE>((tmp & 0xFF0000) >> 16);
+            const BYTE nG = static_cast<BYTE>((tmp & 0xFF00) >> 8);
+            const BYTE nB = static_cast<BYTE>((tmp & 0xFF));
+            return RGB(nR, nG, nB);
+        }
+        catch (const std::exception&)
+        {
+            return fallbackColor;
+        }
+    }
+
+    inline BYTE OpacitySettingToAlpha(int opacity)
+    {
+        return static_cast<BYTE>(opacity * 2.55);
+    }
+
+    template<RECT MONITORINFO::*member>
+    std::vector<std::pair<HMONITOR, RECT>> GetAllMonitorRects()
+    {
+        using result_t = std::vector<std::pair<HMONITOR, RECT>>;
+        result_t result;
+
+        auto enumMonitors = [](HMONITOR monitor, HDC hdc, LPRECT pRect, LPARAM param) -> BOOL {
+            MONITORINFOEX mi;
+            mi.cbSize = sizeof(mi);
+            result_t& result = *reinterpret_cast<result_t*>(param);
+            if (GetMonitorInfo(monitor, &mi))
+            {
+                result.push_back({ monitor, mi.*member });
+            }
+
+            return TRUE;
+        };
+
+        EnumDisplayMonitors(NULL, NULL, enumMonitors, reinterpret_cast<LPARAM>(&result));
+        return result;
+    }
+
+    template<RECT MONITORINFO::*member>
+    std::vector<std::pair<HMONITOR, MONITORINFOEX>> GetAllMonitorInfo()
+    {
+        using result_t = std::vector<std::pair<HMONITOR, MONITORINFOEX>>;
+        result_t result;
+
+        auto enumMonitors = [](HMONITOR monitor, HDC hdc, LPRECT pRect, LPARAM param) -> BOOL {
+            MONITORINFOEX mi;
+            mi.cbSize = sizeof(mi);
+            result_t& result = *reinterpret_cast<result_t*>(param);
+            if (GetMonitorInfo(monitor, &mi))
+            {
+                result.push_back({ monitor, mi });
+            }
+
+            return TRUE;
+        };
+
+        EnumDisplayMonitors(NULL, NULL, enumMonitors, reinterpret_cast<LPARAM>(&result));
+        return result;
+    }
+
+    template<RECT MONITORINFO::*member>
+    RECT GetAllMonitorsCombinedRect()
+    {
+        auto allMonitors = GetAllMonitorRects<member>();
+        bool empty = true;
+        RECT result{ 0, 0, 0, 0 };
+
+        for (auto& [monitor, rect] : allMonitors)
+        {
+            if (empty)
+            {
+                empty = false;
+                result = rect;
+            }
+            else
+            {
+                result.left = min(result.left, rect.left);
+                result.top = min(result.top, rect.top);
+                result.right = max(result.right, rect.right);
+                result.bottom = max(result.bottom, rect.bottom);
+            }
+        }
+
+        return result;
+    }
+
+    std::wstring GetDisplayDeviceId(const std::wstring& device, std::unordered_map<std::wstring, DWORD>& displayDeviceIdxMap);
+
+    UINT GetDpiForMonitor(HMONITOR monitor) noexcept;
+    void OrderMonitors(std::vector<std::pair<HMONITOR, RECT>>& monitorInfo);
+
+    // Parameter rect must be in screen coordinates (e.g. obtained from GetWindowRect)
+    void SizeWindowToRect(HWND window, RECT rect) noexcept;
+
+    bool HasNoVisibleOwner(HWND window) noexcept;
+    bool IsStandardWindow(HWND window);
+    bool IsCandidateForLastKnownZone(HWND window, const std::vector<std::wstring>& excludedApps) noexcept;
+    bool IsCandidateForZoning(HWND window, const std::vector<std::wstring>& excludedApps) noexcept;
+
+    bool IsWindowMaximized(HWND window) noexcept;
+    void SaveWindowSizeAndOrigin(HWND window) noexcept;
+    void RestoreWindowSize(HWND window) noexcept;
+    void RestoreWindowOrigin(HWND window) noexcept;
+
+    bool IsValidGuid(const std::wstring& str);
+
+    std::wstring GenerateUniqueId(HMONITOR monitor, const std::wstring& devideId, const std::wstring& virtualDesktopId);
+    std::wstring GenerateUniqueIdAllMonitorsArea(const std::wstring& virtualDesktopId);
+
+    std::wstring TrimDeviceId(const std::wstring& deviceId);
+    std::optional<FancyZonesDataTypes::DeviceIdData> ParseDeviceId(const std::wstring& deviceId);
+    bool IsValidDeviceId(const std::wstring& str);
+
+    RECT PrepareRectForCycling(RECT windowRect, RECT zoneWindowRect, DWORD vkCode) noexcept;
+    size_t ChooseNextZoneByPosition(DWORD vkCode, RECT windowRect, const std::vector<RECT>& zoneRects) noexcept;
+
+    // If HWND is already dead, we assume it wasn't elevated
+    bool IsProcessOfWindowElevated(HWND window);
+}