[FancyZones] Remove resolution from "device-id" (#17412)

* removed resolution from device id * update applied layouts device id * app zone history device id updated * moved old device id parsing * updated tests * remove resolution in the editor * remove resolution from device id generation * update editor params
2026-04-06 19:26:39 +02:00 · 2022-04-07 11:48:29 +02:00
parent 529bccc0bf
commit 98268cc10a
19 changed files with 969 additions and 928 deletions
--- a/src/modules/fancyzones/FancyZonesLib/FancyZonesData/AppZoneHistory.cpp
+++ b/src/modules/fancyzones/FancyZonesLib/FancyZonesData/AppZoneHistory.cpp
@@ -10,6 +10,207 @@
 #include <FancyZonesLib/JsonHelpers.h>
 #include <FancyZonesLib/util.h>

+namespace JsonUtils
+{
+    struct AppZoneHistoryJSON
+    {
+    private:
+        static std::optional<FancyZonesDataTypes::DeviceIdData> DeviceIdFromJson(const json::JsonObject& json)
+        {
+            try
+            {
+                if (json.HasKey(NonLocalizable::AppZoneHistoryIds::DeviceID))
+                {
+                    json::JsonObject device = json.GetNamedObject(NonLocalizable::AppZoneHistoryIds::DeviceID);
+                    std::wstring monitor = device.GetNamedString(NonLocalizable::AppZoneHistoryIds::MonitorID).c_str();
+                    std::wstring virtualDesktop = device.GetNamedString(NonLocalizable::AppZoneHistoryIds::VirtualDesktopID).c_str();
+
+                    auto virtualDesktopGuid = FancyZonesUtils::GuidFromString(virtualDesktop);
+                    if (!virtualDesktopGuid)
+                    {
+                        return std::nullopt;
+                    }
+
+                    return FancyZonesDataTypes::DeviceIdData{
+                        .deviceName = monitor,
+                        .virtualDesktopId = virtualDesktopGuid.value(),
+                    };
+                }
+                else
+                {
+                    std::wstring deviceIdStr = json.GetNamedString(NonLocalizable::AppZoneHistoryIds::DeviceIdID).c_str();
+                    auto bcDeviceId = BackwardsCompatibility::DeviceIdData::ParseDeviceId(deviceIdStr);
+                    if (!bcDeviceId)
+                    {
+                        return std::nullopt;
+                    }
+
+                    return FancyZonesDataTypes::DeviceIdData{
+                        .deviceName = bcDeviceId->deviceName,
+                        .virtualDesktopId = bcDeviceId->virtualDesktopId,
+                    };
+                }
+            }
+            catch (const winrt::hresult_error&)
+            {
+                return std::nullopt;
+            }
+        }
+
+        static std::optional<FancyZonesDataTypes::AppZoneHistoryData> ParseSingleAppZoneHistoryItem(const json::JsonObject& json)
+        {
+            FancyZonesDataTypes::AppZoneHistoryData data;
+            if (json.HasKey(NonLocalizable::AppZoneHistoryIds::LayoutIndexesID))
+            {
+                data.zoneIndexSet = {};
+                for (const auto& value : json.GetNamedArray(NonLocalizable::AppZoneHistoryIds::LayoutIndexesID))
+                {
+                    data.zoneIndexSet.push_back(static_cast<ZoneIndex>(value.GetNumber()));
+                }
+            }
+            else if (json.HasKey(NonLocalizable::AppZoneHistoryIds::LayoutIndexesID))
+            {
+                data.zoneIndexSet = { static_cast<ZoneIndex>(json.GetNamedNumber(NonLocalizable::AppZoneHistoryIds::LayoutIndexesID)) };
+            }
+
+            auto deviceIdOpt = DeviceIdFromJson(json);
+            if (!deviceIdOpt)
+            {
+                return std::nullopt;
+            }
+
+            data.deviceId = deviceIdOpt.value();
+            data.zoneSetUuid = json.GetNamedString(NonLocalizable::AppZoneHistoryIds::LayoutIdID);
+
+            if (!FancyZonesUtils::IsValidGuid(data.zoneSetUuid))
+            {
+                return std::nullopt;
+            }
+
+            return data;
+        }
+
+    public:
+        std::wstring appPath;
+        std::vector<FancyZonesDataTypes::AppZoneHistoryData> data;
+        
+        static std::optional<AppZoneHistoryJSON> FromJson(const json::JsonObject& json)
+        {
+            try
+            {
+                AppZoneHistoryJSON result;
+
+                result.appPath = json.GetNamedString(NonLocalizable::AppZoneHistoryIds::AppPathID);
+                if (json.HasKey(NonLocalizable::AppZoneHistoryIds::HistoryID))
+                {
+                    auto appHistoryArray = json.GetNamedArray(NonLocalizable::AppZoneHistoryIds::HistoryID);
+                    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(json); 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;
+            }
+        }
+
+        static json::JsonObject ToJson(const AppZoneHistoryJSON& appZoneHistory)
+        {
+            json::JsonObject result{};
+
+            result.SetNamedValue(NonLocalizable::AppZoneHistoryIds::AppPathID, json::value(appZoneHistory.appPath));
+
+            json::JsonArray appHistoryArray;
+            for (const auto& data : appZoneHistory.data)
+            {
+                json::JsonObject desktopData;
+                json::JsonArray jsonIndexSet;
+                for (ZoneIndex index : data.zoneIndexSet)
+                {
+                    jsonIndexSet.Append(json::value(static_cast<int>(index)));
+                }
+
+                json::JsonObject device{};
+                device.SetNamedValue(NonLocalizable::AppZoneHistoryIds::MonitorID, json::value(data.deviceId.deviceName));
+                auto virtualDesktopStr = FancyZonesUtils::GuidToString(data.deviceId.virtualDesktopId);
+                if (virtualDesktopStr)
+                {
+                    device.SetNamedValue(NonLocalizable::AppZoneHistoryIds::VirtualDesktopID, json::value(virtualDesktopStr.value()));
+                }
+
+                desktopData.SetNamedValue(NonLocalizable::AppZoneHistoryIds::LayoutIndexesID, jsonIndexSet);
+                desktopData.SetNamedValue(NonLocalizable::AppZoneHistoryIds::DeviceID, device);
+                desktopData.SetNamedValue(NonLocalizable::AppZoneHistoryIds::LayoutIdID, json::value(data.zoneSetUuid));
+
+                appHistoryArray.Append(desktopData);
+            }
+
+            result.SetNamedValue(NonLocalizable::AppZoneHistoryIds::HistoryID, appHistoryArray);
+
+            return result;
+        }
+    };
+
+    AppZoneHistory::TAppZoneHistoryMap ParseAppZoneHistory(const json::JsonObject& fancyZonesDataJSON)
+    {
+        try
+        {
+            AppZoneHistory::TAppZoneHistoryMap appZoneHistoryMap{};
+            auto appLastZones = fancyZonesDataJSON.GetNamedArray(NonLocalizable::AppZoneHistoryIds::AppZoneHistoryID);
+
+            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::JsonObject SerializeJson(const AppZoneHistory::TAppZoneHistoryMap& map)
+    {
+        json::JsonObject root{};
+        json::JsonArray appHistoryArray{};
+
+        for (const auto& [appPath, appZoneHistoryData] : map)
+        {
+            appHistoryArray.Append(AppZoneHistoryJSON::ToJson(AppZoneHistoryJSON{ appPath, appZoneHistoryData }));
+        }
+
+        root.SetNamedValue(NonLocalizable::AppZoneHistoryIds::AppZoneHistoryID, appHistoryArray);
+        return root;
+    }
+}
+
+
 AppZoneHistory::AppZoneHistory()
 {
 }
@@ -34,7 +235,7 @@ void AppZoneHistory::LoadData()
    {
        if (data)
        {
-            m_history = JSONHelpers::ParseAppZoneHistory(data.value());
+            m_history = JsonUtils::ParseAppZoneHistory(data.value());
        }
        else
        {
@@ -72,11 +273,11 @@ void AppZoneHistory::SaveData()

    if (dirtyFlag)
    {
-        JSONHelpers::SaveAppZoneHistory(AppZoneHistoryFileName(), updatedHistory);
+        json::to_file(AppZoneHistoryFileName(), JsonUtils::SerializeJson(updatedHistory));
    }
    else
    {
-        JSONHelpers::SaveAppZoneHistory(AppZoneHistoryFileName(), m_history);
+        json::to_file(AppZoneHistoryFileName(), JsonUtils::SerializeJson(m_history));
    }
 }

--- a/src/modules/fancyzones/FancyZonesLib/FancyZonesData/AppZoneHistory.h
+++ b/src/modules/fancyzones/FancyZonesLib/FancyZonesData/AppZoneHistory.h
@@ -5,6 +5,22 @@

 #include <common/SettingsAPI/settings_helpers.h>

+namespace NonLocalizable
+{
+    namespace AppZoneHistoryIds
+    {
+        const static wchar_t* AppZoneHistoryID = L"app-zone-history";
+        const static wchar_t* AppPathID = L"app-path";
+        const static wchar_t* HistoryID = L"history";
+        const static wchar_t* LayoutIndexesID = L"zone-index-set";
+        const static wchar_t* LayoutIdID = L"zoneset-uuid";
+        const static wchar_t* DeviceIdID = L"device-id";
+        const static wchar_t* DeviceID = L"device";
+        const static wchar_t* MonitorID = L"monitor";
+        const static wchar_t* VirtualDesktopID = L"virtual-desktop";
+    }
+}
+
 class AppZoneHistory
 {
 public:
--- a/src/modules/fancyzones/FancyZonesLib/FancyZonesData/AppliedLayouts.cpp
+++ b/src/modules/fancyzones/FancyZonesLib/FancyZonesData/AppliedLayouts.cpp
@@ -11,6 +11,19 @@
 #include <FancyZonesLib/JsonHelpers.h>
 #include <FancyZonesLib/util.h>

+namespace 
+{
+    // didn't use default constants since if they'll be changed later, it'll break this function
+    bool isLayoutDefault(const Layout& layout)
+    {
+        return layout.type == FancyZonesDataTypes::ZoneSetLayoutType::PriorityGrid &&
+               layout.zoneCount == 3 &&
+               layout.spacing == 16 &&
+               layout.showSpacing == true &&
+               layout.sensitivityRadius == 20;
+    }
+}
+
 namespace JsonUtils
 {
    struct LayoutJSON
@@ -57,6 +70,50 @@ namespace JsonUtils

    struct AppliedLayoutsJSON
    {
+    private:
+        static std::optional<FancyZonesDataTypes::DeviceIdData> DeviceIdFromJson(const json::JsonObject& json)
+        {
+            try
+            {
+                if (json.HasKey(NonLocalizable::AppliedLayoutsIds::DeviceID))
+                {
+                    json::JsonObject device = json.GetNamedObject(NonLocalizable::AppliedLayoutsIds::DeviceID);
+                    std::wstring monitor = device.GetNamedString(NonLocalizable::AppliedLayoutsIds::MonitorID).c_str();
+                    std::wstring virtualDesktop = device.GetNamedString(NonLocalizable::AppliedLayoutsIds::VirtualDesktopID).c_str();
+
+                    auto virtualDesktopGuid = FancyZonesUtils::GuidFromString(virtualDesktop);
+                    if (!virtualDesktopGuid)
+                    {
+                        return std::nullopt;
+                    }
+
+                    return FancyZonesDataTypes::DeviceIdData{
+                        .deviceName = monitor,
+                        .virtualDesktopId = virtualDesktopGuid.value(),
+                    };
+                }
+                else
+                {
+                    std::wstring deviceIdStr = json.GetNamedString(NonLocalizable::AppliedLayoutsIds::DeviceIdID).c_str();
+                    auto bcDeviceId = BackwardsCompatibility::DeviceIdData::ParseDeviceId(deviceIdStr);
+                    if (!bcDeviceId)
+                    {
+                        return std::nullopt;
+                    }
+
+                    return FancyZonesDataTypes::DeviceIdData{
+                        .deviceName = bcDeviceId->deviceName,
+                        .virtualDesktopId = bcDeviceId->virtualDesktopId,
+                    };
+                }
+            }
+            catch (const winrt::hresult_error&)
+            {
+                return std::nullopt;
+            }
+        }
+
+    public:
        FancyZonesDataTypes::DeviceIdData deviceId;
        Layout data;

@@ -66,9 +123,8 @@ namespace JsonUtils
            {
                AppliedLayoutsJSON result;

-                std::wstring deviceIdStr = json.GetNamedString(NonLocalizable::AppliedLayoutsIds::DeviceIdID).c_str();
-                auto deviceId = FancyZonesDataTypes::DeviceIdData::ParseDeviceId(deviceIdStr);
-                if (!deviceId.has_value())
+                auto deviceIdOpt = DeviceIdFromJson(json);
+                if (!deviceIdOpt.has_value())
                {
                    return std::nullopt;
                }
@@ -79,7 +135,7 @@ namespace JsonUtils
                    return std::nullopt;
                }
                
-                result.deviceId = std::move(deviceId.value());
+                result.deviceId = std::move(deviceIdOpt.value());
                result.data = std::move(layout.value());
                return result;
            }
@@ -91,9 +147,17 @@ namespace JsonUtils

        static json::JsonObject ToJson(const AppliedLayoutsJSON& value)
        {
-            json::JsonObject result{};
+            json::JsonObject device{};
+            device.SetNamedValue(NonLocalizable::AppliedLayoutsIds::MonitorID, json::value(value.deviceId.deviceName));

-            result.SetNamedValue(NonLocalizable::AppliedLayoutsIds::DeviceIdID, json::value(value.deviceId.toString()));
+            auto virtualDesktopStr = FancyZonesUtils::GuidToString(value.deviceId.virtualDesktopId);
+            if (virtualDesktopStr)
+            {
+                device.SetNamedValue(NonLocalizable::AppliedLayoutsIds::VirtualDesktopID, json::value(virtualDesktopStr.value()));
+            }
+
+            json::JsonObject result{};
+            result.SetNamedValue(NonLocalizable::AppliedLayoutsIds::DeviceID, device);
            result.SetNamedValue(NonLocalizable::AppliedLayoutsIds::AppliedLayoutID, JsonUtils::LayoutJSON::ToJson(value.data));
            
            return result;
@@ -109,7 +173,12 @@ namespace JsonUtils
        {
            if (auto obj = AppliedLayoutsJSON::FromJson(layouts.GetObjectAt(i)); obj.has_value())
            {
-                map[obj->deviceId] = std::move(obj->data);
+                // skip default layouts in case if they were applied to different resolutions on the same monitor.
+                // NOTE: keep the default layout check for users who update PT version from the v0.57 
+                if (!map.contains(obj->deviceId) && !isLayoutDefault(obj->data))
+                {
+                    map[obj->deviceId] = std::move(obj->data);
+                }
            }
        }

--- a/src/modules/fancyzones/FancyZonesLib/FancyZonesData/AppliedLayouts.h
+++ b/src/modules/fancyzones/FancyZonesLib/FancyZonesData/AppliedLayouts.h
@@ -16,6 +16,9 @@ namespace NonLocalizable
    {
        const static wchar_t* AppliedLayoutsArrayID = L"applied-layouts";
        const static wchar_t* DeviceIdID = L"device-id";
+        const static wchar_t* DeviceID = L"device";
+        const static wchar_t* MonitorID = L"monitor";
+        const static wchar_t* VirtualDesktopID = L"virtual-desktop";
        const static wchar_t* AppliedLayoutID = L"applied-layout";
        const static wchar_t* UuidID = L"uuid";
        const static wchar_t* TypeID = L"type";