diff --git a/TrafficMonitor/ClassicalTaskbarDlg.cpp b/TrafficMonitor/ClassicalTaskbarDlg.cpp
index 8fe4a0529..ca7d8db51 100644
--- a/TrafficMonitor/ClassicalTaskbarDlg.cpp
+++ b/TrafficMonitor/ClassicalTaskbarDlg.cpp
@@ -33,7 +33,7 @@ void CClassicalTaskbarDlg::AdjustTaskbarWndPos(bool force_adjust)
 
             //设置任务栏窗口的垂直位置
             m_rect.MoveToY((m_rcBar.Height() - m_rect.Height()) / 2);
-            if (theApp.m_taskbar_data.horizontal_arrange && theApp.m_win_version.IsWindows7())
+            if (theApp.m_taskbar_data.IsHorizontalArrangeForDisplay(GetDisplayIndex()) && theApp.m_win_version.IsWindows7())
                 m_rect.MoveToY(m_rect.top + DPI(1));
             MoveWindow(m_rect);
         }
diff --git a/TrafficMonitor/CommonData.cpp b/TrafficMonitor/CommonData.cpp
index 1370983ba..45d6d1531 100644
--- a/TrafficMonitor/CommonData.cpp
+++ b/TrafficMonitor/CommonData.cpp
@@ -251,9 +251,298 @@ void TaskBarSettingData::ValidWindowOffsetTop()
 void TaskBarSettingData::ValidWindowOffsetLeft()
 {
     if (window_offset_left < -800)
-        window_offset_top = -800;
-    if (window_offset_top > 800)
-        window_offset_top = 800;
+        window_offset_left = -800;
+    if (window_offset_left > 800)
+        window_offset_left = 800;
+}
+
+DisplayItemSet TaskBarSettingData::GetDisplayItemForDisplay(int display_index) const
+{
+    auto iter = display_item_per_display.find(display_index);
+    if (iter != display_item_per_display.end())
+    {
+        DisplayItemSet display_item_set;
+        display_item_set.FromInt(iter->second);
+        return display_item_set;
+    }
+    return display_item;
+}
+
+void TaskBarSettingData::SetDisplayItemForDisplay(int display_index, const DisplayItemSet& display_item_value)
+{
+    display_item_per_display[display_index] = display_item_value.ToInt();
+    if (display_index == 0)
+        display_item = display_item_value;
+}
+
+int TaskBarSettingData::GetItemSpaceForDisplay(int display_index) const
+{
+    auto iter = item_space_per_display.find(display_index);
+    if (iter != item_space_per_display.end())
+        return iter->second;
+    return item_space;
+}
+
+void TaskBarSettingData::SetItemSpaceForDisplay(int display_index, int value)
+{
+    int clamped_value = value;
+    if (clamped_value < 0)
+        clamped_value = 0;
+    if (clamped_value > 32)
+        clamped_value = 32;
+
+    item_space_per_display[display_index] = clamped_value;
+    if (display_index == 0)
+        item_space = clamped_value;
+}
+
+int TaskBarSettingData::GetVerticalMarginForDisplay(int display_index) const
+{
+    auto iter = vertical_margin_per_display.find(display_index);
+    if (iter != vertical_margin_per_display.end())
+        return iter->second;
+    return vertical_margin;
+}
+
+void TaskBarSettingData::SetVerticalMarginForDisplay(int display_index, int value)
+{
+    int clamped_value = value;
+    if (clamped_value < -10)
+        clamped_value = -10;
+    if (clamped_value > 10)
+        clamped_value = 10;
+
+    vertical_margin_per_display[display_index] = clamped_value;
+    if (display_index == 0)
+        vertical_margin = clamped_value;
+}
+
+bool TaskBarSettingData::IsSpeedShortModeForDisplay(int display_index) const
+{
+    auto iter = speed_short_mode_per_display.find(display_index);
+    if (iter != speed_short_mode_per_display.end())
+        return iter->second;
+    return speed_short_mode;
+}
+
+void TaskBarSettingData::SetSpeedShortModeForDisplay(int display_index, bool speed_short_mode_value)
+{
+    speed_short_mode_per_display[display_index] = speed_short_mode_value;
+    if (display_index == 0)
+        speed_short_mode = speed_short_mode_value;
+}
+
+bool TaskBarSettingData::IsValueRightAlignForDisplay(int display_index) const
+{
+    auto iter = value_right_align_per_display.find(display_index);
+    if (iter != value_right_align_per_display.end())
+        return iter->second;
+    return value_right_align;
+}
+
+void TaskBarSettingData::SetValueRightAlignForDisplay(int display_index, bool value_right_align_value)
+{
+    value_right_align_per_display[display_index] = value_right_align_value;
+    if (display_index == 0)
+        value_right_align = value_right_align_value;
+}
+
+int TaskBarSettingData::GetDigitsNumberForDisplay(int display_index) const
+{
+    auto iter = digits_number_per_display.find(display_index);
+    if (iter != digits_number_per_display.end())
+    {
+        int value = iter->second;
+        if (value < 3)
+            value = 3;
+        if (value > 7)
+            value = 7;
+        return value;
+    }
+
+    int value = digits_number;
+    if (value < 3)
+        value = 3;
+    if (value > 7)
+        value = 7;
+    return value;
+}
+
+void TaskBarSettingData::SetDigitsNumberForDisplay(int display_index, int digits_number_value)
+{
+    int clamped_value = digits_number_value;
+    if (clamped_value < 3)
+        clamped_value = 3;
+    if (clamped_value > 7)
+        clamped_value = 7;
+
+    digits_number_per_display[display_index] = clamped_value;
+    if (display_index == 0)
+        digits_number = clamped_value;
+}
+
+bool TaskBarSettingData::IsHorizontalArrangeForDisplay(int display_index) const
+{
+    auto iter = horizontal_arrange_per_display.find(display_index);
+    if (iter != horizontal_arrange_per_display.end())
+        return iter->second;
+    return horizontal_arrange;
+}
+
+void TaskBarSettingData::SetHorizontalArrangeForDisplay(int display_index, bool horizontal_arrange_value)
+{
+    horizontal_arrange_per_display[display_index] = horizontal_arrange_value;
+    if (display_index == 0)
+        horizontal_arrange = horizontal_arrange_value;
+}
+
+bool TaskBarSettingData::IsSeparateValueUnitWithSpaceForDisplay(int display_index) const
+{
+    auto iter = separate_value_unit_with_space_per_display.find(display_index);
+    if (iter != separate_value_unit_with_space_per_display.end())
+        return iter->second;
+    return separate_value_unit_with_space;
+}
+
+void TaskBarSettingData::SetSeparateValueUnitWithSpaceForDisplay(int display_index, bool separate_value_unit_with_space_value)
+{
+    separate_value_unit_with_space_per_display[display_index] = separate_value_unit_with_space_value;
+    if (display_index == 0)
+        separate_value_unit_with_space = separate_value_unit_with_space_value;
+}
+
+bool TaskBarSettingData::IsShowToolTipForDisplay(int display_index) const
+{
+    auto iter = show_tool_tip_per_display.find(display_index);
+    if (iter != show_tool_tip_per_display.end())
+        return iter->second;
+    return show_tool_tip;
+}
+
+void TaskBarSettingData::SetShowToolTipForDisplay(int display_index, bool show_tool_tip_value)
+{
+    show_tool_tip_per_display[display_index] = show_tool_tip_value;
+    if (display_index == 0)
+        show_tool_tip = show_tool_tip_value;
+}
+
+MemoryDisplay TaskBarSettingData::GetMemoryDisplayForDisplay(int display_index) const
+{
+    auto iter = memory_display_per_display.find(display_index);
+    if (iter != memory_display_per_display.end())
+    {
+        int value = iter->second;
+        if (value < static_cast<int>(MemoryDisplay::USAGE_PERCENTAGE) || value > static_cast<int>(MemoryDisplay::MEMORY_AVAILABLE))
+            return memory_display;
+        return static_cast<MemoryDisplay>(value);
+    }
+    return memory_display;
+}
+
+void TaskBarSettingData::SetMemoryDisplayForDisplay(int display_index, MemoryDisplay memory_display_value)
+{
+    int value = static_cast<int>(memory_display_value);
+    if (value < static_cast<int>(MemoryDisplay::USAGE_PERCENTAGE))
+        value = static_cast<int>(MemoryDisplay::USAGE_PERCENTAGE);
+    if (value > static_cast<int>(MemoryDisplay::MEMORY_AVAILABLE))
+        value = static_cast<int>(MemoryDisplay::MEMORY_AVAILABLE);
+
+    memory_display_per_display[display_index] = value;
+    if (display_index == 0)
+        memory_display = static_cast<MemoryDisplay>(value);
+}
+
+int TaskBarSettingData::GetWindowOffsetTopForDisplay(int display_index) const
+{
+    auto iter = window_offset_top_per_display.find(display_index);
+    if (iter != window_offset_top_per_display.end())
+        return iter->second;
+    return window_offset_top;
+}
+
+void TaskBarSettingData::SetWindowOffsetTopForDisplay(int display_index, int value)
+{
+    int clamped_value = value;
+    if (clamped_value < -20)
+        clamped_value = -20;
+    if (clamped_value > 20)
+        clamped_value = 20;
+
+    window_offset_top_per_display[display_index] = clamped_value;
+    if (display_index == 0)
+        window_offset_top = clamped_value;
+}
+
+int TaskBarSettingData::GetWindowOffsetLeftForDisplay(int display_index) const
+{
+    auto iter = window_offset_left_per_display.find(display_index);
+    if (iter != window_offset_left_per_display.end())
+        return iter->second;
+    return window_offset_left;
+}
+
+void TaskBarSettingData::SetWindowOffsetLeftForDisplay(int display_index, int value)
+{
+    int clamped_value = value;
+    if (clamped_value < -800)
+        clamped_value = -800;
+    if (clamped_value > 800)
+        clamped_value = 800;
+
+    window_offset_left_per_display[display_index] = clamped_value;
+    if (display_index == 0)
+        window_offset_left = clamped_value;
+}
+
+bool TaskBarSettingData::IsTaskbarWndSnapForDisplay(int display_index) const
+{
+    auto iter = tbar_wnd_snap_per_display.find(display_index);
+    if (iter != tbar_wnd_snap_per_display.end())
+        return iter->second;
+    return tbar_wnd_snap;
+}
+
+void TaskBarSettingData::SetTaskbarWndSnapForDisplay(int display_index, bool snap)
+{
+    tbar_wnd_snap_per_display[display_index] = snap;
+    if (display_index == 0)
+        tbar_wnd_snap = snap;
+}
+
+bool TaskBarSettingData::IsAvoidOverlapWithWidgetsForDisplay(int display_index) const
+{
+    auto iter = avoid_overlap_with_widgets_per_display.find(display_index);
+    if (iter != avoid_overlap_with_widgets_per_display.end())
+        return iter->second;
+    return avoid_overlap_with_widgets;
+}
+
+void TaskBarSettingData::SetAvoidOverlapWithWidgetsForDisplay(int display_index, bool avoid_overlap)
+{
+    avoid_overlap_with_widgets_per_display[display_index] = avoid_overlap;
+    if (display_index == 0)
+        avoid_overlap_with_widgets = avoid_overlap;
+}
+
+int TaskBarSettingData::GetTaskbarLeftSpaceForDisplay(int display_index) const
+{
+    auto iter = taskbar_left_space_win11_per_display.find(display_index);
+    if (iter != taskbar_left_space_win11_per_display.end())
+        return iter->second;
+    return taskbar_left_space_win11;
+}
+
+void TaskBarSettingData::SetTaskbarLeftSpaceForDisplay(int display_index, int value)
+{
+    int clamped_value = value;
+    if (clamped_value < 0)
+        clamped_value = 0;
+    if (clamped_value > 300)
+        clamped_value = 300;
+
+    taskbar_left_space_win11_per_display[display_index] = clamped_value;
+    if (display_index == 0)
+        taskbar_left_space_win11 = clamped_value;
 }
 
 unsigned __int64 TaskBarSettingData::GetNetspeedFigureMaxValueInBytes() const
diff --git a/TrafficMonitor/CommonData.h b/TrafficMonitor/CommonData.h
index 5d6f6b322..0d3ef02f0 100644
--- a/TrafficMonitor/CommonData.h
+++ b/TrafficMonitor/CommonData.h
@@ -312,27 +312,71 @@ struct TaskBarSettingData : public PublicSettingData
     DisplayItemSet display_item{ TDI_UP, TDI_DOWN };      //任务栏窗口显示的项目
     StringSet plugin_display_item;                  //任务窗口显示的插件项目
 
-    bool show_taskbar_wnd_in_secondary_display{ false };    //是否在副显示器上显示任务栏窗口
-    int secondary_display_index{};      //在第几个副显示器上显示任务栏窗口
+    std::set<int> taskbar_display_indices{ 0 };    //显示任务栏窗口的显示器序号：0为主显示器，1及以上为副显示器序号+1
+    std::map<int, int> display_item_per_display;    //各显示器显示项目覆盖值，key: 显示器序号, value: DisplayItemSet::ToInt()
+    std::map<int, bool> speed_short_mode_per_display;    //网速简洁模式覆盖值，key: 显示器序号
     bool value_right_align{ false };    //数值是否右对齐
+    std::map<int, bool> value_right_align_per_display;   //数值右对齐覆盖值，key: 显示器序号
     int digits_number{ 4 };             //数据位数
+    std::map<int, int> digits_number_per_display;    //数据位数覆盖值，key: 显示器序号
     bool horizontal_arrange{ true };    //水平排列
+    std::map<int, bool> horizontal_arrange_per_display;  //水平排列覆盖值，key: 显示器序号
     bool show_status_bar{ true };       //显示 CPU/内存的状态条
+    std::map<int, bool> separate_value_unit_with_space_per_display; //数值和单位空格分隔覆盖值，key: 显示器序号
+    std::map<int, bool> show_tool_tip_per_display;   //鼠标提示覆盖值，key: 显示器序号
+    std::map<int, int> memory_display_per_display;   //内存显示方式覆盖值，key: 显示器序号，value: MemoryDisplay
     bool tbar_wnd_on_left{ false };     //如果为true，则任务栏窗口显示在任务栏的左侧（或上方）
     bool tbar_wnd_snap{ false };     	//如果为true，则在Win11中任务栏窗口贴靠中间任务栏，否则靠近边缘
+    std::map<int, bool> tbar_wnd_snap_per_display; //Win11下任务栏窗口贴靠方式覆盖值，key: 显示器序号
     bool cm_graph_type{ false };        //如果为false，默认原样式，柱状图显示占用率，如为true，滚动显示占用率
     bool show_graph_dashed_box{ true }; //显示占用图虚线框
 
     int item_space{};                   //项目间距
+    std::map<int, int> item_space_per_display;      //各显示器项目间距覆盖值，key: 显示器序号
     int vertical_margin{};              //项目垂直间距
+    std::map<int, int> vertical_margin_per_display; //各显示器垂直间距覆盖值，key: 显示器序号
     int window_offset_top{};            //任务栏窗口顶部边距
+    std::map<int, int> window_offset_top_per_display;   //Win11任务栏窗口顶部偏移覆盖值，key: 显示器序号
     int window_offset_left{};           //任务栏窗口左侧边距
+    std::map<int, int> window_offset_left_per_display;  //Win11任务栏窗口左侧偏移覆盖值，key: 显示器序号
     void ValidItemSpace();
     void ValidVerticalMargin();
     void ValidWindowOffsetTop();
     void ValidWindowOffsetLeft();
+    DisplayItemSet GetDisplayItemForDisplay(int display_index) const;
+    void SetDisplayItemForDisplay(int display_index, const DisplayItemSet& display_item_value);
+    int GetItemSpaceForDisplay(int display_index) const;
+    void SetItemSpaceForDisplay(int display_index, int value);
+    int GetVerticalMarginForDisplay(int display_index) const;
+    void SetVerticalMarginForDisplay(int display_index, int value);
+    bool IsSpeedShortModeForDisplay(int display_index) const;
+    void SetSpeedShortModeForDisplay(int display_index, bool speed_short_mode);
+    bool IsValueRightAlignForDisplay(int display_index) const;
+    void SetValueRightAlignForDisplay(int display_index, bool value_right_align);
+    int GetDigitsNumberForDisplay(int display_index) const;
+    void SetDigitsNumberForDisplay(int display_index, int digits_number);
+    bool IsHorizontalArrangeForDisplay(int display_index) const;
+    void SetHorizontalArrangeForDisplay(int display_index, bool horizontal_arrange);
+    bool IsSeparateValueUnitWithSpaceForDisplay(int display_index) const;
+    void SetSeparateValueUnitWithSpaceForDisplay(int display_index, bool separate_value_unit_with_space);
+    bool IsShowToolTipForDisplay(int display_index) const;
+    void SetShowToolTipForDisplay(int display_index, bool show_tool_tip);
+    MemoryDisplay GetMemoryDisplayForDisplay(int display_index) const;
+    void SetMemoryDisplayForDisplay(int display_index, MemoryDisplay memory_display);
+    int GetWindowOffsetTopForDisplay(int display_index) const;
+    void SetWindowOffsetTopForDisplay(int display_index, int value);
+    int GetWindowOffsetLeftForDisplay(int display_index) const;
+    void SetWindowOffsetLeftForDisplay(int display_index, int value);
+    bool IsTaskbarWndSnapForDisplay(int display_index) const;
+    void SetTaskbarWndSnapForDisplay(int display_index, bool snap);
     bool avoid_overlap_with_widgets{ false };   //避免与右侧小组件重叠
+    std::map<int, bool> avoid_overlap_with_widgets_per_display; //Win11下避免与右侧小组件重叠覆盖值，key: 显示器序号
+    bool IsAvoidOverlapWithWidgetsForDisplay(int display_index) const;
+    void SetAvoidOverlapWithWidgetsForDisplay(int display_index, bool avoid_overlap);
     int taskbar_left_space_win11{};         //Windows11下，任务栏小工具的宽度
+    std::map<int, int> taskbar_left_space_win11_per_display; //Win11下小工具宽度覆盖值，key: 显示器序号
+    int GetTaskbarLeftSpaceForDisplay(int display_index) const;
+    void SetTaskbarLeftSpaceForDisplay(int display_index, int value);
     int taskbar_right_space_win11{};        //Windows11下，任务栏窗口距离任务栏右侧的宽度（仅当无法获取到任务栏TrayNotifyWnd窗口的位置时有效）
 
     bool show_netspeed_figure{ false };     //是否显示网速占用图
diff --git a/TrafficMonitor/DisplayItem.cpp b/TrafficMonitor/DisplayItem.cpp
index 127440738..bafbd624a 100644
--- a/TrafficMonitor/DisplayItem.cpp
+++ b/TrafficMonitor/DisplayItem.cpp
@@ -182,7 +182,7 @@ const wchar_t* CommonDisplayItem::GetItemIniKeyName() const
     }
 }
 
-CString CommonDisplayItem::GetItemValueText(bool is_main_window) const
+CString CommonDisplayItem::GetItemValueText(bool is_main_window, const TaskBarSettingData* taskbar_data) const
 {
     if (is_plugin)
     {
@@ -193,6 +193,8 @@ CString CommonDisplayItem::GetItemValueText(bool is_main_window) const
         const PublicSettingData* cfg_data{};
         if (is_main_window)
             cfg_data = &theApp.m_main_wnd_data;
+        else if (taskbar_data != nullptr)
+            cfg_data = taskbar_data;
         else
             cfg_data = &theApp.m_taskbar_data;
         CString str_value;
@@ -275,7 +277,7 @@ CString CommonDisplayItem::GetItemValueText(bool is_main_window) const
     }
 }
 
-CString CommonDisplayItem::GetItemValueSampleText(bool is_main_window) const
+CString CommonDisplayItem::GetItemValueSampleText(bool is_main_window, const TaskBarSettingData* taskbar_data) const
 {
     if (is_plugin)
     {
@@ -320,6 +322,7 @@ CString CommonDisplayItem::GetItemValueSampleText(bool is_main_window) const
     //任务栏窗口（用于计算任务栏窗口宽度）
     else
     {
+        const TaskBarSettingData* cfg_data = (taskbar_data != nullptr ? taskbar_data : &theApp.m_taskbar_data);
         CString sample_str;
         switch (item_type)
         {
@@ -328,9 +331,9 @@ CString CommonDisplayItem::GetItemValueSampleText(bool is_main_window) const
         case TDI_DOWN:
         case TDI_TOTAL_SPEED:
         {
-            wstring digits(theApp.m_taskbar_data.digits_number, L'8');      //根据数据位数生成指定个数的“8”
-            bool hide_unit{ theApp.m_taskbar_data.hide_unit && theApp.m_taskbar_data.speed_unit != SpeedUnit::AUTO };
-            if (theApp.m_taskbar_data.speed_short_mode)
+            wstring digits(cfg_data->digits_number, L'8');      //根据数据位数生成指定个数的“8”
+            bool hide_unit{ cfg_data->hide_unit && cfg_data->speed_unit != SpeedUnit::AUTO };
+            if (cfg_data->speed_short_mode)
             {
                 if (hide_unit)
                     sample_str.Format(_T("%s."), digits.c_str());
@@ -344,9 +347,9 @@ CString CommonDisplayItem::GetItemValueSampleText(bool is_main_window) const
                 else
                     sample_str.Format(_T("%s.8MB/s"), digits.c_str());
             }
-            if (!hide_unit && theApp.m_taskbar_data.separate_value_unit_with_space)
+            if (!hide_unit && cfg_data->separate_value_unit_with_space)
                 sample_str += _T(' ');
-            if (theApp.m_taskbar_data.speed_short_mode && !theApp.m_taskbar_data.unit_byte && !theApp.m_taskbar_data.hide_unit)
+            if (cfg_data->speed_short_mode && !cfg_data->unit_byte && !cfg_data->hide_unit)
                 sample_str += _T('b');
         }
             break;
@@ -357,9 +360,9 @@ CString CommonDisplayItem::GetItemValueSampleText(bool is_main_window) const
         case TDI_HDD_USAGE:
         {
             sample_str = _T("100");
-            if (!theApp.m_taskbar_data.hide_percent)
+            if (!cfg_data->hide_percent)
             {
-                if (theApp.m_taskbar_data.separate_value_unit_with_space)
+                if (cfg_data->separate_value_unit_with_space)
                     sample_str += _T(" %");
                 else
                     sample_str += _T("%");
@@ -367,10 +370,10 @@ CString CommonDisplayItem::GetItemValueSampleText(bool is_main_window) const
             //内存显示不为已使用百分比时
             if (item_type == TDI_MEMORY)
             {
-                if (theApp.m_taskbar_data.memory_display == MemoryDisplay::MEMORY_USED || theApp.m_taskbar_data.memory_display == MemoryDisplay::MEMORY_AVAILABLE)
+                if (cfg_data->memory_display == MemoryDisplay::MEMORY_USED || cfg_data->memory_display == MemoryDisplay::MEMORY_AVAILABLE)
                 {
                     //宽度为总内存的宽度
-                    sample_str = CCommon::DataSizeToString(static_cast<unsigned long long>(theApp.m_total_memory) * 1024, theApp.m_taskbar_data.separate_value_unit_with_space);
+                    sample_str = CCommon::DataSizeToString(static_cast<unsigned long long>(theApp.m_total_memory) * 1024, cfg_data->separate_value_unit_with_space);
                 }
             }
         }
@@ -381,7 +384,7 @@ CString CommonDisplayItem::GetItemValueSampleText(bool is_main_window) const
         case TDI_HDD_TEMP:
         case TDI_MAIN_BOARD_TEMP:
         {
-            if (theApp.m_taskbar_data.separate_value_unit_with_space)
+            if (cfg_data->separate_value_unit_with_space)
                 sample_str = _T("99 °C");
             else
                 sample_str = _T("99°C");
@@ -390,7 +393,7 @@ CString CommonDisplayItem::GetItemValueSampleText(bool is_main_window) const
         //CPU频率
         case TDI_CPU_FREQ:
         {
-            if (theApp.m_taskbar_data.separate_value_unit_with_space)
+            if (cfg_data->separate_value_unit_with_space)
                 sample_str = _T("1.00 GHz");
             else
                 sample_str = _T("1.00GHz");
@@ -399,7 +402,7 @@ CString CommonDisplayItem::GetItemValueSampleText(bool is_main_window) const
         //流量
         case TDI_TODAY_TRAFFIC:
         {
-            if (theApp.m_taskbar_data.separate_value_unit_with_space)
+            if (cfg_data->separate_value_unit_with_space)
                 sample_str = _T("999.99 MB");
             else
                 sample_str = _T("999.99MB");
diff --git a/TrafficMonitor/DisplayItem.h b/TrafficMonitor/DisplayItem.h
index abd47d5fa..7b12cf33d 100644
--- a/TrafficMonitor/DisplayItem.h
+++ b/TrafficMonitor/DisplayItem.h
@@ -1,6 +1,8 @@
 #pragma once
 #include "PluginInterface.h"
 
+struct TaskBarSettingData;
+
 //内置的显示的项目
 enum DisplayItem
 {
@@ -63,14 +65,14 @@ class CommonDisplayItem
      * @param   is_main_window 如果为true则为主窗口，否则为任务栏窗口
      * @return  显示的文本
      */
-    CString GetItemValueText(bool is_main_window) const;
+    CString GetItemValueText(bool is_main_window, const TaskBarSettingData* taskbar_data = nullptr) const;
 
     /**
      * @brief   获取一个显示项目的数值示例文本
      * @param   is_main_window 如果为true则为主窗口，否则为任务栏窗口
      * @return  示例文本
      */
-    CString GetItemValueSampleText(bool is_main_window) const;
+    CString GetItemValueSampleText(bool is_main_window, const TaskBarSettingData* taskbar_data = nullptr) const;
 
 private:
     bool is_plugin{};           //是否为插件项目
diff --git a/TrafficMonitor/GeneralSettingsDlg.cpp b/TrafficMonitor/GeneralSettingsDlg.cpp
index 00bc373e4..9579dcb41 100644
--- a/TrafficMonitor/GeneralSettingsDlg.cpp
+++ b/TrafficMonitor/GeneralSettingsDlg.cpp
@@ -27,21 +27,29 @@ CGeneralSettingsDlg::~CGeneralSettingsDlg()
 
 void CGeneralSettingsDlg::CheckTaskbarDisplayItem()
 {
-    //如果选项设置中关闭了某个硬件监控，则不显示对应的温度监控相关项目
-    if (!theApp.m_general_data.IsHardwareEnable(HI_CPU))
-    {
-        theApp.m_taskbar_data.display_item.Remove(TDI_CPU_TEMP);
-    }
-    if (!theApp.m_general_data.IsHardwareEnable(HI_GPU))
+    auto filter_display_item_set = [](DisplayItemSet& display_item_set)
     {
-        theApp.m_taskbar_data.display_item.Remove(TDI_GPU_TEMP);
-    }
-    if (!theApp.m_general_data.IsHardwareEnable(HI_HDD))
+        //如果选项设置中关闭了某个硬件监控，则不显示对应的温度监控相关项目
+        if (!theApp.m_general_data.IsHardwareEnable(HI_CPU))
+            display_item_set.Remove(TDI_CPU_TEMP);
+        if (!theApp.m_general_data.IsHardwareEnable(HI_GPU))
+            display_item_set.Remove(TDI_GPU_TEMP);
+        if (!theApp.m_general_data.IsHardwareEnable(HI_HDD))
+            display_item_set.Remove(TDI_HDD_TEMP);
+        if (!theApp.m_general_data.IsHardwareEnable(HI_MBD))
+            display_item_set.Remove(TDI_MAIN_BOARD_TEMP);
+    };
+
+    //如果选项设置中关闭了某个硬件监控，则不显示对应的温度监控相关项目
+    filter_display_item_set(theApp.m_taskbar_data.display_item);
+
+    for (auto& item : theApp.m_taskbar_data.display_item_per_display)
     {
-        theApp.m_taskbar_data.display_item.Remove(TDI_HDD_TEMP);
+        DisplayItemSet display_item_set;
+        display_item_set.FromInt(item.second);
+        filter_display_item_set(display_item_set);
+        item.second = display_item_set.ToInt();
     }
-    if (!theApp.m_general_data.IsHardwareEnable(HI_MBD))
-        theApp.m_taskbar_data.display_item.Remove(TDI_MAIN_BOARD_TEMP);
 }
 
 void CGeneralSettingsDlg::SetControlMouseWheelEnable(bool enable)
diff --git a/TrafficMonitor/TaskBarDlg.cpp b/TrafficMonitor/TaskBarDlg.cpp
index 9f731131f..c3ee82656 100644
--- a/TrafficMonitor/TaskBarDlg.cpp
+++ b/TrafficMonitor/TaskBarDlg.cpp
@@ -57,6 +57,32 @@ END_MESSAGE_MAP()
 
 // CTaskBarDlg 消息处理程序
 
+const TaskBarSettingData& CTaskBarDlg::GetDisplayTaskbarData() const
+{
+    if (!m_display_taskbar_data_cache_valid)
+    {
+        m_display_taskbar_data_cache = theApp.m_taskbar_data;
+        int display_index = GetDisplayIndex();
+        m_display_taskbar_data_cache.display_item = theApp.m_taskbar_data.GetDisplayItemForDisplay(display_index);
+        m_display_taskbar_data_cache.speed_short_mode = theApp.m_taskbar_data.IsSpeedShortModeForDisplay(display_index);
+        m_display_taskbar_data_cache.value_right_align = theApp.m_taskbar_data.IsValueRightAlignForDisplay(display_index);
+        m_display_taskbar_data_cache.digits_number = theApp.m_taskbar_data.GetDigitsNumberForDisplay(display_index);
+        m_display_taskbar_data_cache.horizontal_arrange = theApp.m_taskbar_data.IsHorizontalArrangeForDisplay(display_index);
+        m_display_taskbar_data_cache.separate_value_unit_with_space = theApp.m_taskbar_data.IsSeparateValueUnitWithSpaceForDisplay(display_index);
+        m_display_taskbar_data_cache.show_tool_tip = theApp.m_taskbar_data.IsShowToolTipForDisplay(display_index);
+        m_display_taskbar_data_cache.memory_display = theApp.m_taskbar_data.GetMemoryDisplayForDisplay(display_index);
+        m_display_taskbar_data_cache.item_space = theApp.m_taskbar_data.GetItemSpaceForDisplay(display_index);
+        m_display_taskbar_data_cache.vertical_margin = theApp.m_taskbar_data.GetVerticalMarginForDisplay(display_index);
+        m_display_taskbar_data_cache_valid = true;
+    }
+    return m_display_taskbar_data_cache;
+}
+
+void CTaskBarDlg::InvalidateDisplayTaskbarDataCache()
+{
+    m_display_taskbar_data_cache_valid = false;
+}
+
 void CTaskBarDlg::ShowInfo(CDC* pDC)
 {
     m_item_rects.clear();   //绘图前先清除所有项目的矩形区域
@@ -91,6 +117,9 @@ void CTaskBarDlg::ShowInfo(CDC* pDC)
     auto render_type = m_supported_render_enums.GetAutoFitEnum();
     CRect draw_rect{m_rect}; // 绘图的矩形区域
     draw_rect.MoveToXY(0, 0);
+    const TaskBarSettingData& display_data = GetDisplayTaskbarData();
+    const int item_space = display_data.item_space;
+    const int vertical_margin = display_data.vertical_margin;
 
 #ifdef DEBUG
     Microsoft::WRL::ComPtr<IDXGraphicsAnalysis> p_dxgi_analysis{};
@@ -195,16 +224,16 @@ void CTaskBarDlg::ShowInfo(CDC* pDC)
         //任务栏在桌面顶部或底部
         if (IsTasksbarOnTopOrBottom())
         {
-            if (theApp.m_taskbar_data.horizontal_arrange) //水平排列
+            if (display_data.horizontal_arrange) //水平排列
             {
                 if (index > 0)
-                    item_rect.MoveToX(item_rect.right + DPI(theApp.m_taskbar_data.item_space));
+                    item_rect.MoveToX(item_rect.right + DPI(item_space));
                 item_rect.right = item_rect.left + iter->item_width.TotalWidth();
                 item_rect.bottom = item_rect.top + m_window_height;
                 if (iter->IsPlugin())
-                    DrawPluginItem(draw, iter->PluginItem(), item_rect, iter->item_width.label_width);
+                    DrawPluginItem(draw, iter->PluginItem(), item_rect, iter->item_width.label_width, display_data);
                 else
-                    DrawDisplayItem(draw, iter->ItemType(), item_rect, iter->item_width.label_width);
+                    DrawDisplayItem(draw, iter->ItemType(), item_rect, iter->item_width.label_width, display_data);
             }
             else //非水平排列时，每两个一组显示
             {
@@ -213,35 +242,35 @@ void CTaskBarDlg::ShowInfo(CDC* pDC)
                 {
                     CRect item_rect_up;     //上面一个项目的矩形区域
                     if (index > 0)
-                        item_rect_up.MoveToXY(item_rect.right + DPI(theApp.m_taskbar_data.item_space), -DPI(theApp.m_taskbar_data.vertical_margin));
+                        item_rect_up.MoveToXY(item_rect.right + DPI(item_space), -DPI(vertical_margin));
                     item_rect.left = item_rect_up.left;
                     item_rect.top = (m_window_height - TASKBAR_WND_HEIGHT / 2);
                     //确定窗口大小
                     item_rect_up.bottom = item_rect.top - 1;
-                    item_rect.bottom = m_window_height + DPI(theApp.m_taskbar_data.vertical_margin);
+                    item_rect.bottom = m_window_height + DPI(vertical_margin);
                     int width = max(iter->item_width.TotalWidth(), last_item_width.TotalWidth());
                     item_rect.right = item_rect.left + width;
                     item_rect_up.right = item_rect_up.left + width;
                     //绘制信息
                     if (last_iter->IsPlugin())
-                        DrawPluginItem(draw, last_iter->PluginItem(), item_rect_up, last_item_width.label_width);
+                        DrawPluginItem(draw, last_iter->PluginItem(), item_rect_up, last_item_width.label_width, display_data);
                     else
-                        DrawDisplayItem(draw, last_iter->ItemType(), item_rect_up, last_item_width.label_width);
+                        DrawDisplayItem(draw, last_iter->ItemType(), item_rect_up, last_item_width.label_width, display_data);
                     if (iter->IsPlugin())
-                        DrawPluginItem(draw, iter->PluginItem(), item_rect, iter->item_width.label_width);
+                        DrawPluginItem(draw, iter->PluginItem(), item_rect, iter->item_width.label_width, display_data);
                     else
-                        DrawDisplayItem(draw, iter->ItemType(), item_rect, iter->item_width.label_width);
+                        DrawDisplayItem(draw, iter->ItemType(), item_rect, iter->item_width.label_width, display_data);
                 }
                 //要绘制的项目为奇数时绘制最后一个
                 else if (item_count % 2 == 1 && index == item_count - 1)
                 {
-                    item_rect.MoveToXY(item_rect.right + DPI(theApp.m_taskbar_data.item_space), 0);
+                    item_rect.MoveToXY(item_rect.right + DPI(item_space), 0);
                     item_rect.bottom = TASKBAR_WND_HEIGHT;
                     item_rect.right = item_rect.left + iter->item_width.MaxWidth();
                     if (iter->IsPlugin())
-                        DrawPluginItem(draw, iter->PluginItem(), item_rect, iter->item_width.label_width, true);
+                        DrawPluginItem(draw, iter->PluginItem(), item_rect, iter->item_width.label_width, display_data, true);
                     else
-                        DrawDisplayItem(draw, iter->ItemType(), item_rect, iter->item_width.label_width, true);
+                        DrawDisplayItem(draw, iter->ItemType(), item_rect, iter->item_width.label_width, display_data, true);
                 }
             }
         }
@@ -249,13 +278,13 @@ void CTaskBarDlg::ShowInfo(CDC* pDC)
         else
         {
             if (index > 0)
-                item_rect.MoveToXY(0, item_rect.bottom + DPI(theApp.m_taskbar_data.item_space));
+                item_rect.MoveToXY(0, item_rect.bottom + DPI(item_space));
             item_rect.bottom = item_rect.top + TASKBAR_WND_HEIGHT / 2;
-            item_rect.right = item_rect.left + min(m_window_width, m_rcTaskbar.Width() - DPI(theApp.m_taskbar_data.item_space));
+            item_rect.right = item_rect.left + min(m_window_width, m_rcTaskbar.Width() - DPI(item_space));
             if (iter->IsPlugin())
-                DrawPluginItem(draw, iter->PluginItem(), item_rect, iter->item_width.label_width);
+                DrawPluginItem(draw, iter->PluginItem(), item_rect, iter->item_width.label_width, display_data);
             else
-                DrawDisplayItem(draw, iter->ItemType(), item_rect, iter->item_width.label_width);
+                DrawDisplayItem(draw, iter->ItemType(), item_rect, iter->item_width.label_width, display_data);
         }
         index++;
         last_iter = iter;
@@ -269,7 +298,7 @@ void CTaskBarDlg::ShowInfo(CDC* pDC)
 #endif
 }
 
-void CTaskBarDlg::DrawDisplayItem(IDrawCommon& drawer, DisplayItem type, CRect rect, int label_width, bool vertical)
+void CTaskBarDlg::DrawDisplayItem(IDrawCommon& drawer, DisplayItem type, CRect rect, int label_width, const TaskBarSettingData& display_data, bool vertical)
 {
     m_item_rects[type] = rect;
     //设置要绘制的文本颜色
@@ -371,14 +400,14 @@ void CTaskBarDlg::DrawDisplayItem(IDrawCommon& drawer, DisplayItem type, CRect r
     }
 
     //绘制数值
-    IDrawCommon::Alignment value_alignment{ theApp.m_taskbar_data.value_right_align ? IDrawCommon::Alignment::RIGHT : IDrawCommon::Alignment::LEFT };      //数值的对齐方式
+    IDrawCommon::Alignment value_alignment{ display_data.value_right_align ? IDrawCommon::Alignment::RIGHT : IDrawCommon::Alignment::LEFT };      //数值的对齐方式
     if (vertical)
         value_alignment = IDrawCommon::Alignment::CENTER;
-    CString str_value = CommonDisplayItem(type).GetItemValueText(false);
+    CString str_value = CommonDisplayItem(type).GetItemValueText(false, &display_data);
     drawer.DrawWindowText(rect_value, str_value, text_color, value_alignment);
 }
 
-void CTaskBarDlg::DrawPluginItem(IDrawCommon& drawer, IPluginItem* item, CRect rect, int label_width, bool vertical)
+void CTaskBarDlg::DrawPluginItem(IDrawCommon& drawer, IPluginItem* item, CRect rect, int label_width, const TaskBarSettingData& display_data, bool vertical)
 {
     if (item == nullptr)
         return;
@@ -477,7 +506,7 @@ void CTaskBarDlg::DrawPluginItem(IDrawCommon& drawer, IPluginItem* item, CRect r
         CString lable_text = theApp.m_taskbar_data.disp_str.GetConst(item).c_str();
         drawer.DrawWindowText(rect_label, lable_text, label_text_color, (vertical ? IDrawCommon::Alignment::CENTER : IDrawCommon::Alignment::LEFT));
         //画数值
-        IDrawCommon::Alignment value_alignment{ theApp.m_taskbar_data.value_right_align ? IDrawCommon::Alignment::RIGHT : IDrawCommon::Alignment::LEFT };      //数值的对齐方式
+        IDrawCommon::Alignment value_alignment{ display_data.value_right_align ? IDrawCommon::Alignment::RIGHT : IDrawCommon::Alignment::LEFT };      //数值的对齐方式
         if (vertical)
             value_alignment = IDrawCommon::Alignment::CENTER;
         drawer.DrawWindowText(rect_value, item->GetItemValueText(), value_text_color, value_alignment);
@@ -535,12 +564,11 @@ bool CTaskBarDlg::AdjustWindowPos(bool force_adjust)
 
     ::GetWindowRect(m_hTaskbar, m_rcTaskbar);   //获得任务栏的矩形区域
 
-    static bool last_taskbar_on_top_or_bottom;
     CheckTaskbarOnTopOrBottom();
-    if (force_adjust || m_taskbar_on_top_or_bottom != last_taskbar_on_top_or_bottom)
+    if (force_adjust || m_taskbar_on_top_or_bottom != m_last_taskbar_on_top_or_bottom)
     {
         CalculateWindowSize();
-        last_taskbar_on_top_or_bottom = m_taskbar_on_top_or_bottom;
+        m_last_taskbar_on_top_or_bottom = m_taskbar_on_top_or_bottom;
         force_adjust = true;
     }
 
@@ -619,6 +647,7 @@ void CTaskBarDlg::ApplyWindowTransparentColor()
 
 void CTaskBarDlg::WidthChanged()
 {
+    InvalidateDisplayTaskbarDataCache();
     m_is_width_changed = true;
 }
 
@@ -671,15 +700,18 @@ HWND CTaskBarDlg::FindTaskbarHandle(bool& is_scendary_display)
 {
     is_scendary_display = false;
     HWND hTaskbar = nullptr;
+
+    bool show_in_secondary_display = (m_display_target == DisplayTarget::SECONDARY_DISPLAY);
+
     //显示在副显示器上
-    if (theApp.m_taskbar_data.show_taskbar_wnd_in_secondary_display && CWindowsSettingHelper::IsTaskbarShowingInAllDisplays())
+    if (show_in_secondary_display && CWindowsSettingHelper::IsTaskbarShowingInAllDisplays())
     {
         //获取所有副显示器的任务栏
         std::vector<HWND> secondary_taskbars;
         CTaskbarHelper::GetAllSecondaryDisplayTaskbar(secondary_taskbars);
         if (!secondary_taskbars.empty())
         {
-            int index = theApp.m_taskbar_data.secondary_display_index;
+            int index = m_secondary_display_index;
             if (index < 0)
                 index = 0;
             if (index >= static_cast<int>(secondary_taskbars.size()))
@@ -697,6 +729,7 @@ HWND CTaskBarDlg::FindTaskbarHandle(bool& is_scendary_display)
 
 CString CTaskBarDlg::GetMouseTipsInfo()
 {
+    const TaskBarSettingData& display_data = GetDisplayTaskbarData();
     CString tip_info;
     CString temp;
     temp.Format(_T("%s: %s\r\n (%s: %s/%s: %s)"), CCommon::LoadText(IDS_TRAFFIC_USED_TODAY),
@@ -708,13 +741,13 @@ CString CTaskBarDlg::GetMouseTipsInfo()
     if (!IsItemShow(TDI_UP))
     {
         temp.Format(_T("\r\n%s: %s/s"), CCommon::LoadText(IDS_UPLOAD),
-            CCommon::DataSizeToString(theApp.m_out_speed, theApp.m_taskbar_data));
+            CCommon::DataSizeToString(theApp.m_out_speed, display_data));
         tip_info += temp;
     }
     if (!IsItemShow(TDI_DOWN))
     {
         temp.Format(_T("\r\n%s: %s/s"), CCommon::LoadText(IDS_DOWNLOAD),
-            CCommon::DataSizeToString(theApp.m_in_speed, theApp.m_taskbar_data));
+            CCommon::DataSizeToString(theApp.m_in_speed, display_data));
         tip_info += temp;
     }
     if (!IsItemShow(TDI_CPU))
@@ -744,7 +777,7 @@ CString CTaskBarDlg::GetMouseTipsInfo()
     }
     if (!IsItemShow(TDI_CPU_FREQ) && theApp.m_cpu_freq > 0)
     {
-        temp.Format(_T("\r\n%s: %s"), CCommon::LoadText(IDS_CPU_FREQ), CCommon::FreqToString(theApp.m_cpu_freq, theApp.m_taskbar_data));
+        temp.Format(_T("\r\n%s: %s"), CCommon::LoadText(IDS_CPU_FREQ), CCommon::FreqToString(theApp.m_cpu_freq, display_data));
         tip_info += temp;
     }
 
@@ -760,22 +793,22 @@ CString CTaskBarDlg::GetMouseTipsInfo()
     {
         if (!IsItemShow(TDI_CPU_TEMP) && theApp.m_cpu_temperature > 0)
         {
-            temp.Format(_T("\r\n%s: %s"), CCommon::LoadText(IDS_CPU_TEMPERATURE), CCommon::TemperatureToString(theApp.m_cpu_temperature, theApp.m_taskbar_data));
+            temp.Format(_T("\r\n%s: %s"), CCommon::LoadText(IDS_CPU_TEMPERATURE), CCommon::TemperatureToString(theApp.m_cpu_temperature, display_data));
             tip_info += temp;
         }
         if (!IsItemShow(TDI_GPU_TEMP) && theApp.m_gpu_temperature > 0)
         {
-            temp.Format(_T("\r\n%s: %s"), CCommon::LoadText(IDS_GPU_TEMPERATURE), CCommon::TemperatureToString(theApp.m_gpu_temperature, theApp.m_taskbar_data));
+            temp.Format(_T("\r\n%s: %s"), CCommon::LoadText(IDS_GPU_TEMPERATURE), CCommon::TemperatureToString(theApp.m_gpu_temperature, display_data));
             tip_info += temp;
         }
         if (!IsItemShow(TDI_HDD_TEMP) && theApp.m_hdd_temperature > 0)
         {
-            temp.Format(_T("\r\n%s: %s"), CCommon::LoadText(IDS_HDD_TEMPERATURE), CCommon::TemperatureToString(theApp.m_hdd_temperature, theApp.m_taskbar_data));
+            temp.Format(_T("\r\n%s: %s"), CCommon::LoadText(IDS_HDD_TEMPERATURE), CCommon::TemperatureToString(theApp.m_hdd_temperature, display_data));
             tip_info += temp;
         }
         if (!IsItemShow(TDI_MAIN_BOARD_TEMP) && theApp.m_main_board_temperature > 0)
         {
-            temp.Format(_T("\r\n%s: %s"), CCommon::LoadText(IDS_MAINBOARD_TEMPERATURE), CCommon::TemperatureToString(theApp.m_main_board_temperature, theApp.m_taskbar_data));
+            temp.Format(_T("\r\n%s: %s"), CCommon::LoadText(IDS_MAINBOARD_TEMPERATURE), CCommon::TemperatureToString(theApp.m_main_board_temperature, display_data));
             tip_info += temp;
         }
     }
@@ -805,15 +838,18 @@ void CTaskBarDlg::SetTextFont()
 
 void CTaskBarDlg::ApplySettings()
 {
+    InvalidateDisplayTaskbarDataCache();
     SetTextFont();
     CalculateWindowSize();
 }
 
 void CTaskBarDlg::CalculateWindowSize()
 {
-    bool horizontal_arrange = theApp.m_taskbar_data.horizontal_arrange && m_taskbar_on_top_or_bottom;
-    if (theApp.m_taskbar_data.display_item.IsEmpty() && theApp.m_taskbar_data.plugin_display_item.data().empty())
-        theApp.m_taskbar_data.display_item.Add(TDI_UP);        //至少显示一项
+    TaskBarSettingData display_data = GetDisplayTaskbarData();
+    const int item_space = display_data.item_space;
+    bool horizontal_arrange = display_data.horizontal_arrange && m_taskbar_on_top_or_bottom;
+    if (display_data.display_item.IsEmpty() && display_data.plugin_display_item.data().empty())
+        display_data.display_item.Add(TDI_UP);        //至少显示一项
 
     m_item_widths.clear();
     //显示项目的宽度
@@ -851,7 +887,7 @@ void CTaskBarDlg::CalculateWindowSize()
             //标签宽度
             item_widths[*iter].label_width = m_pDC->GetTextExtent(theApp.m_taskbar_data.disp_str.GetConst(*iter).c_str()).cx;
             //数值宽度
-            CString sample_str = iter->GetItemValueSampleText(false);
+            CString sample_str = iter->GetItemValueSampleText(false, &display_data);
             item_widths[*iter].value_width = m_pDC->GetTextExtent(sample_str).cx;
         }
     }
@@ -859,7 +895,18 @@ void CTaskBarDlg::CalculateWindowSize()
     auto item_order{ theApp.m_taskbar_data.item_order.GetAllDisplayItemsWithOrder() };
     for (const auto& item : item_order)
     {
-        if (theApp.IsTaksbarItemDisplayed(item))
+        bool is_item_displayed{};
+        if (item.IsPlugin())
+        {
+            if (item.PluginItem() != nullptr)
+                is_item_displayed = display_data.plugin_display_item.Contains(item.PluginItem()->GetItemId());
+        }
+        else
+        {
+            is_item_displayed = display_data.display_item.Contains(item.ItemType());
+        }
+
+        if (is_item_displayed)
         {
             ItemWidthInfo width_info = item;
             width_info.item_width = item_widths[item];
@@ -873,13 +920,13 @@ void CTaskBarDlg::CalculateWindowSize()
     if (IsTasksbarOnTopOrBottom())  //任务栏在桌面的顶部或底部时
     {
         m_window_width = 0;
-        if (theApp.m_taskbar_data.horizontal_arrange)   //水平排列时
+        if (horizontal_arrange)   //水平排列时
         {
             for (auto iter = m_item_widths.begin(); iter != m_item_widths.end(); ++iter)
             {
                 m_window_width += iter->item_width.TotalWidth();
             }
-            m_window_width += DPI(theApp.m_taskbar_data.item_space) * item_count;   //加上每个标签间的空隙
+            m_window_width += DPI(item_space) * item_count;   //加上每个标签间的空隙
         }
         else        //非水平排列时，每两个一组排列
         {
@@ -903,7 +950,7 @@ void CTaskBarDlg::CalculateWindowSize()
                 index++;
             }
 
-            m_window_width += DPI(theApp.m_taskbar_data.item_space) * ((item_count + 1) / 2 + 1);   //加上每个标签间的空隙
+            m_window_width += DPI(item_space) * ((item_count + 1) / 2 + 1);   //加上每个标签间的空隙
         }
     }
     else        //任务栏在桌面两侧时
@@ -928,7 +975,7 @@ void CTaskBarDlg::CalculateWindowSize()
     else
     {
         m_window_height = TASKBAR_WND_HEIGHT / 2 * item_count;
-        m_window_height += (DPI(theApp.m_taskbar_data.item_space) * item_count);   //加上每个标签间的空隙
+        m_window_height += (DPI(item_space) * item_count);   //加上每个标签间的空隙
     }
     m_rect.right = m_rect.left + m_window_width;
     m_rect.bottom = m_rect.top + m_window_height;
@@ -942,7 +989,7 @@ void CTaskBarDlg::SetToolTipsTopMost()
 
 void CTaskBarDlg::UpdateToolTips()
 {
-    if (theApp.m_taskbar_data.show_tool_tip && IsWindow(m_tool_tips.GetSafeHwnd()))
+    if (theApp.m_taskbar_data.IsShowToolTipForDisplay(GetDisplayIndex()) && IsWindow(m_tool_tips.GetSafeHwnd()))
     {
         CString tip_info;
         tip_info = GetMouseTipsInfo();
@@ -952,17 +999,19 @@ void CTaskBarDlg::UpdateToolTips()
 
 bool CTaskBarDlg::IsItemShow(DisplayItem item)
 {
-    return (theApp.m_taskbar_data.display_item.Contains(item));
+    return GetDisplayTaskbarData().display_item.Contains(item);
 }
 
 bool CTaskBarDlg::IsShowCpuMemory()
 {
-    return (theApp.m_taskbar_data.display_item.Contains(TDI_CPU) || theApp.m_taskbar_data.display_item.Contains(TDI_MEMORY));
+    const TaskBarSettingData& display_data = GetDisplayTaskbarData();
+    return (display_data.display_item.Contains(TDI_CPU) || display_data.display_item.Contains(TDI_MEMORY));
 }
 
 bool CTaskBarDlg::IsShowNetSpeed()
 {
-    return (theApp.m_taskbar_data.display_item.Contains(TDI_UP) || theApp.m_taskbar_data.display_item.Contains(TDI_DOWN));
+    const TaskBarSettingData& display_data = GetDisplayTaskbarData();
+    return (display_data.display_item.Contains(TDI_UP) || display_data.display_item.Contains(TDI_DOWN));
 }
 
 bool CTaskBarDlg::IsTaskbarCloseToIconEnable(bool taskbar_wnd_on_left)
@@ -1017,7 +1066,10 @@ BOOL CTaskBarDlg::OnInitDialog()
     m_pDC->SelectObject(&m_font);
 
     CheckTaskbarOnTopOrBottom();
+    InvalidateDisplayTaskbarDataCache();
     CalculateWindowSize();
+    m_last_window_width_for_timer = m_window_width;
+    m_last_window_height_for_timer = m_window_height;
     m_rect.SetRectEmpty();
     m_rect.bottom = m_window_height;
     m_rect.right = m_rect.left + m_window_width;
@@ -1149,7 +1201,7 @@ void CTaskBarDlg::OnInitMenu(CMenu* pMenu)
         }
     }
 
-    ::SendMessage(theApp.m_pMainWnd->GetSafeHwnd(), WM_TASKBAR_MENU_POPED_UP, 0, 0); //通知主窗口菜单已弹出
+    ::SendMessage(theApp.m_pMainWnd->GetSafeHwnd(), WM_TASKBAR_MENU_POPED_UP, reinterpret_cast<WPARAM>(this), 0); //通知主窗口菜单已弹出
 }
 
 BOOL CTaskBarDlg::PreTranslateMessage(MSG* pMsg)
@@ -1159,7 +1211,7 @@ BOOL CTaskBarDlg::PreTranslateMessage(MSG* pMsg)
     if (pMsg->message == WM_KEYDOWN && pMsg->wParam == VK_ESCAPE) return TRUE;
     if (pMsg->message == WM_KEYDOWN && pMsg->wParam == VK_RETURN) return TRUE;
 
-    if (theApp.m_taskbar_data.show_tool_tip && !m_menu_popuped && IsWindow(m_tool_tips.GetSafeHwnd()) && (pMsg->message == WM_LBUTTONDOWN ||
+    if (theApp.m_taskbar_data.IsShowToolTipForDisplay(GetDisplayIndex()) && !m_menu_popuped && IsWindow(m_tool_tips.GetSafeHwnd()) && (pMsg->message == WM_LBUTTONDOWN ||
         pMsg->message == WM_LBUTTONUP ||
         pMsg->message == WM_MOUSEMOVE))
     {
@@ -1238,14 +1290,12 @@ void CTaskBarDlg::OnTimer(UINT_PTR nIDEvent)
         }
         
         //每秒钟重新计算窗口的宽度，如果发生变化，则重新调整任务栏窗口位置
-        static int last_window_width = m_window_width;
-        static int last_window_height = m_window_height;
         CalculateWindowSize();
-        if (last_window_width != m_window_width || last_window_height != m_window_height)
+        if (m_last_window_width_for_timer != m_window_width || m_last_window_height_for_timer != m_window_height)
         {
             WidthChanged();
-            last_window_width = m_window_width;
-            last_window_height = m_window_height;
+            m_last_window_width_for_timer = m_window_width;
+            m_last_window_height_for_timer = m_window_height;
         }
     }
 
diff --git a/TrafficMonitor/TaskBarDlg.h b/TrafficMonitor/TaskBarDlg.h
index 8037d04a8..5fa5c3285 100644
--- a/TrafficMonitor/TaskBarDlg.h
+++ b/TrafficMonitor/TaskBarDlg.h
@@ -21,6 +21,12 @@ class CTaskBarDlg : public CDialogEx
     DECLARE_DYNAMIC(CTaskBarDlg)
 
 public:
+    enum class DisplayTarget
+    {
+        PRIMARY_DISPLAY,
+        SECONDARY_DISPLAY
+    };
+
     CTaskBarDlg(CWnd* pParent = NULL);   // 标准构造函数
     virtual ~CTaskBarDlg();
 
@@ -38,6 +44,21 @@ class CTaskBarDlg : public CDialogEx
 
     void WidthChanged();    //调用此函数通知任务栏窗口宽度改变以强制调整一次任务栏窗口位置
 
+    void SetDisplayTarget(DisplayTarget target, int secondary_display_index = 0)
+    {
+        m_display_target = target;
+        m_secondary_display_index = secondary_display_index;
+        InvalidateDisplayTaskbarDataCache();
+    }
+    DisplayTarget GetDisplayTarget() const { return m_display_target; }
+    int GetSecondaryDisplayIndex() const { return m_secondary_display_index; }
+    int GetDisplayIndex() const
+    {
+        if (m_display_target == DisplayTarget::SECONDARY_DISPLAY)
+            return m_secondary_display_index + 1;
+        return 0;
+    }
+
     //获取用于检查DPI的矩形区域
     const CRect& GetRectForDpiCheck() const;
 
@@ -148,6 +169,13 @@ class CTaskBarDlg : public CDialogEx
     bool m_menu_popuped{ false };               //指示当前是否有菜单处于弹出状态
     bool m_is_secondary_display{ false };       //是否显示在副显示器中
     bool m_is_width_changed{ false };
+    bool m_last_taskbar_on_top_or_bottom{ true };
+    int m_last_window_width_for_timer{};
+    int m_last_window_height_for_timer{};
+    DisplayTarget m_display_target{ DisplayTarget::PRIMARY_DISPLAY };
+    int m_secondary_display_index{};
+    mutable TaskBarSettingData m_display_taskbar_data_cache{};
+    mutable bool m_display_taskbar_data_cache_valid{};
 
     UINT m_taskbar_dpi{};//TaskBarDlg自身专用dpi
 
@@ -173,7 +201,7 @@ class CTaskBarDlg : public CDialogEx
     //  rect: 绘制矩形区域
     //  label_width: 标签区域的宽度
     //  vertical: 如果为true，则标签和数值上下显示
-    void DrawDisplayItem(IDrawCommon& drawer, DisplayItem type, CRect rect, int label_width, bool vertical = false);
+    void DrawDisplayItem(IDrawCommon& drawer, DisplayItem type, CRect rect, int label_width, const TaskBarSettingData& display_data, bool vertical = false);
 
     //绘制任务栏窗口中的一个插件项目
    //  drawer: 绘图类的对象
@@ -181,7 +209,10 @@ class CTaskBarDlg : public CDialogEx
    //  rect: 绘制矩形区域
    //  label_width: 标签区域的宽度
    //  vertical: 如果为true，则标签和数值上下显示
-    void DrawPluginItem(IDrawCommon& drawer, IPluginItem* item, CRect rect, int label_width, bool vertical = false);
+    void DrawPluginItem(IDrawCommon& drawer, IPluginItem* item, CRect rect, int label_width, const TaskBarSettingData& display_data, bool vertical = false);
+
+    const TaskBarSettingData& GetDisplayTaskbarData() const;
+    void InvalidateDisplayTaskbarDataCache();
 
     void MoveWindow(CRect rect);
 
@@ -198,9 +229,9 @@ class CTaskBarDlg : public CDialogEx
     int GetErrorCode() const { return m_error_code; }
     bool IsTasksbarOnTopOrBottom() const { return m_taskbar_on_top_or_bottom; }
 
-    static bool IsItemShow(DisplayItem item);
-    static bool IsShowCpuMemory();
-    static bool IsShowNetSpeed();
+    bool IsItemShow(DisplayItem item);
+    bool IsShowCpuMemory();
+    bool IsShowNetSpeed();
 
     CommonDisplayItem GetClickedItem() const { return m_clicked_item; }
 
diff --git a/TrafficMonitor/TaskBarSettingsDlg.cpp b/TrafficMonitor/TaskBarSettingsDlg.cpp
index a1d35199d..e902a824a 100644
--- a/TrafficMonitor/TaskBarSettingsDlg.cpp
+++ b/TrafficMonitor/TaskBarSettingsDlg.cpp
@@ -98,6 +98,108 @@ void CTaskBarSettingsDlg::ModifyDefaultStyle(int index)
     theApp.m_taskbar_default_style.ModifyDefaultStyle(index, m_data);
 }
 
+int CTaskBarSettingsDlg::GetCurrentDisplayIndex()
+{
+    int item_count = m_displays_list.GetCount();
+    if (item_count <= 0)
+        return 0;
+
+    int index = m_displays_list.GetCurSel();
+    if (index == LB_ERR && m_current_display_index >= 0 && m_current_display_index < item_count)
+        index = m_current_display_index;
+    if (index == LB_ERR)
+        index = 0;
+
+    m_current_display_index = index;
+    return index;
+}
+
+CString CTaskBarSettingsDlg::GetDisplayNameText(int display_index) const
+{
+    if (display_index <= 0)
+        return CCommon::LoadText(IDS_PRIMARY_DISPLAY);
+    return CCommon::LoadTextFormat(IDS_SECONDARY_DISPLAY, { display_index });
+}
+
+void CTaskBarSettingsDlg::UpdateTaskbarDisplaySelection()
+{
+    m_data.taskbar_display_indices.clear();
+    int item_count = m_displays_list.GetCount();
+    if (item_count <= 0)
+        return;
+
+    for (int i = 0; i < item_count; i++)
+    {
+        if (m_displays_list.GetCheck(i) != 0)
+            m_data.taskbar_display_indices.insert(i);
+    }
+
+    //至少保留一个显示器，避免任务栏窗口配置为空
+    if (m_data.taskbar_display_indices.empty())
+    {
+        m_displays_list.SetCheck(0, TRUE);
+        m_data.taskbar_display_indices.insert(0);
+    }
+}
+
+void CTaskBarSettingsDlg::UpdatePerDisplayLayoutEditControls()
+{
+    int display_index = GetCurrentDisplayIndex();
+    CString display_name = GetDisplayNameText(display_index);
+
+    m_updating_per_display_controls = true;
+    ((CButton*)GetDlgItem(IDC_SPEED_SHORT_MODE_CHECK))->SetCheck(m_data.IsSpeedShortModeForDisplay(display_index));
+    ((CButton*)GetDlgItem(IDC_VALUE_RIGHT_ALIGN_CHECK))->SetCheck(m_data.IsValueRightAlignForDisplay(display_index));
+    ((CButton*)GetDlgItem(IDC_HORIZONTAL_ARRANGE_CHECK))->SetCheck(m_data.IsHorizontalArrangeForDisplay(display_index));
+    ((CButton*)GetDlgItem(IDC_SEPARATE_VALUE_UNIT_CHECK))->SetCheck(m_data.IsSeparateValueUnitWithSpaceForDisplay(display_index));
+    ((CButton*)GetDlgItem(IDC_SHOW_TOOL_TIP_CHK))->SetCheck(m_data.IsShowToolTipForDisplay(display_index));
+
+    int digit_number_index = m_data.GetDigitsNumberForDisplay(display_index) - 3;
+    if (digit_number_index < 0)
+        digit_number_index = 0;
+    if (digit_number_index > 4)
+        digit_number_index = 4;
+    m_digit_number_combo.SetCurSel(digit_number_index);
+
+    int memory_display_index = static_cast<int>(m_data.GetMemoryDisplayForDisplay(display_index));
+    if (memory_display_index < 0)
+        memory_display_index = 0;
+    if (memory_display_index > 2)
+        memory_display_index = 2;
+    m_memory_display_combo.SetCurSel(memory_display_index);
+
+    m_item_space_edit.SetValue(m_data.GetItemSpaceForDisplay(display_index));
+    m_vertical_margin_edit.SetValue(m_data.GetVerticalMarginForDisplay(display_index));
+
+    if (m_layout_settings_prefix_text.IsEmpty())
+    {
+        GetDlgItemText(IDC_DISPLAY_SETTINGS_GROUP_STATIC, m_layout_settings_prefix_text);
+        if (m_layout_settings_prefix_text.IsEmpty())
+            m_layout_settings_prefix_text = CCommon::LoadText(L"TXT_DISPLAY_SETTINGS");
+    }
+
+    CString group_text;
+    group_text.Format(_T("%s - %s"), m_layout_settings_prefix_text.GetString(), display_name.GetString());
+    SetDlgItemText(IDC_DISPLAY_SETTINGS_GROUP_STATIC, group_text);
+
+    if (m_win11_settings_button_text.IsEmpty())
+        GetDlgItemText(IDC_WIN11_SETTINGS_BUTTON, m_win11_settings_button_text);
+
+    CString button_text;
+    button_text.Format(_T("%s - %s"), m_win11_settings_button_text.GetString(), display_name.GetString());
+    SetDlgItemText(IDC_WIN11_SETTINGS_BUTTON, button_text);
+
+    CWnd* p_win11_button = GetDlgItem(IDC_WIN11_SETTINGS_BUTTON);
+    if (p_win11_button != nullptr)
+    {
+        CString tip_text;
+        tip_text.Format(_T("%s: %s"), m_win11_settings_button_text.GetString(), display_name.GetString());
+        m_toolTip.UpdateTipText(tip_text, p_win11_button);
+    }
+
+    m_updating_per_display_controls = false;
+}
+
 void CTaskBarSettingsDlg::EnableControl()
 {
     bool exe_path_enable = (m_data.double_click_action == DoubleClickAction::SEPCIFIC_APP);
@@ -129,7 +231,6 @@ void CTaskBarSettingsDlg::SetControlMouseWheelEnable(bool enable)
     m_vertical_margin_edit.SetMouseWheelEnable(enable);
     m_net_speed_figure_max_val_edit.SetMouseWheelEnable(enable);
     m_net_speed_figure_max_val_unit_combo.SetMouseWheelEnable(enable);
-    m_displays_combo.SetMouseWheelEnable(enable);
 }
 
 bool CTaskBarSettingsDlg::InitializeControls()
@@ -176,7 +277,7 @@ bool CTaskBarSettingsDlg::InitializeControls()
         { CtrlTextInfo::C0, IDC_DISPLAY_TO_SHOW_TASKBAR_WND_COMBO }
     });
     RepositionTextBasedControls({
-        { CtrlTextInfo::L4, IDC_WIN11_SETTINGS_BUTTON, CtrlTextInfo::W16 }
+        { CtrlTextInfo::L4, IDC_WIN11_SETTINGS_BUTTON, CtrlTextInfo::W128 }
     });
     RepositionTextBasedControls({
         { CtrlTextInfo::L1, IDC_DOUBLE_CLICK_ACTION_STATIC },
@@ -224,7 +325,7 @@ void CTaskBarSettingsDlg::DoDataExchange(CDataExchange* pDX)
     DDX_Control(pDX, IDC_VERTICAL_MARGIN_EDIT, m_vertical_margin_edit);
     DDX_Control(pDX, IDC_NET_SPEED_FIGURE_MAX_VALUE_EDIT, m_net_speed_figure_max_val_edit);
     DDX_Control(pDX, IDC_NET_SPEED_FIGURE_MAX_VALUE_UNIT_COMBO, m_net_speed_figure_max_val_unit_combo);
-    DDX_Control(pDX, IDC_DISPLAY_TO_SHOW_TASKBAR_WND_COMBO, m_displays_combo);
+    DDX_Control(pDX, IDC_DISPLAY_TO_SHOW_TASKBAR_WND_COMBO, m_displays_list);
 }
 
 
@@ -268,8 +369,8 @@ BEGIN_MESSAGE_MAP(CTaskBarSettingsDlg, CTabDlg)
     ON_BN_CLICKED(IDC_ENABLE_COLOR_EMOJI_CHECK, &CTaskBarSettingsDlg::OnBnClickedEnableColorEmojiCheck)
     ON_CBN_SELCHANGE(IDC_DIGIT_NUMBER_COMBO, &CTaskBarSettingsDlg::OnCbnSelchangeDigitNumberCombo)
     ON_BN_CLICKED(IDC_WIN11_SETTINGS_BUTTON, &CTaskBarSettingsDlg::OnBnClickedWin11SettingsButton)
-    ON_BN_CLICKED(IDC_TASKBAR_WND_IN_SECONDARY_DISPLAY_CHECK, &CTaskBarSettingsDlg::OnBnClickedTaskbarWndInSecondaryDisplayCheck)
-    ON_CBN_SELCHANGE(IDC_DISPLAY_TO_SHOW_TASKBAR_WND_COMBO, &CTaskBarSettingsDlg::OnCbnSelchangeDisplayToShowTaskbarWndCombo)
+    ON_CLBN_CHKCHANGE(IDC_DISPLAY_TO_SHOW_TASKBAR_WND_COMBO, &CTaskBarSettingsDlg::OnLbnSelchangeDisplayToShowTaskbarWndList)
+    ON_LBN_SELCHANGE(IDC_DISPLAY_TO_SHOW_TASKBAR_WND_COMBO, &CTaskBarSettingsDlg::OnLbnSelchangeDisplayToShowTaskbarWndList)
     ON_BN_CLICKED(IDC_USAGE_GRAPH_FOLLOW_SYSTEM_CHECK, &CTaskBarSettingsDlg::OnBnClickedUsageGraphFollowSystemCheck)
     ON_EN_CHANGE(IDC_FONT_SIZE_EDIT1, &CTaskBarSettingsDlg::OnEnChangeFontSizeEdit1)
 END_MESSAGE_MAP()
@@ -301,14 +402,12 @@ BOOL CTaskBarSettingsDlg::OnInitDialog()
 
     //((CButton*)GetDlgItem(IDC_SWITCH_UP_DOWN_CHECK1))->SetCheck(m_data.swap_up_down);
     ((CButton*)GetDlgItem(IDC_TASKBAR_WND_ON_LEFT_CHECK))->SetCheck(m_data.tbar_wnd_on_left);
-    ((CButton*)GetDlgItem(IDC_SPEED_SHORT_MODE_CHECK))->SetCheck(m_data.speed_short_mode);
-    ((CButton*)GetDlgItem(IDC_VALUE_RIGHT_ALIGN_CHECK))->SetCheck(m_data.value_right_align);
-    ((CButton*)GetDlgItem(IDC_HORIZONTAL_ARRANGE_CHECK))->SetCheck(m_data.horizontal_arrange);
+    ((CButton*)GetDlgItem(IDC_SPEED_SHORT_MODE_CHECK))->SetCheck(m_data.IsSpeedShortModeForDisplay(0));
+    ((CButton*)GetDlgItem(IDC_VALUE_RIGHT_ALIGN_CHECK))->SetCheck(m_data.IsValueRightAlignForDisplay(0));
+    ((CButton*)GetDlgItem(IDC_HORIZONTAL_ARRANGE_CHECK))->SetCheck(m_data.IsHorizontalArrangeForDisplay(0));
     ((CButton*)GetDlgItem(IDC_SHOW_STATUS_BAR_CHECK))->SetCheck(m_data.show_status_bar);
-    ((CButton*)GetDlgItem(IDC_SEPARATE_VALUE_UNIT_CHECK))->SetCheck(m_data.separate_value_unit_with_space);
-    ((CButton*)GetDlgItem(IDC_SHOW_TOOL_TIP_CHK))->SetCheck(m_data.show_tool_tip);
-
-    CheckDlgButton(IDC_TASKBAR_WND_IN_SECONDARY_DISPLAY_CHECK, m_data.show_taskbar_wnd_in_secondary_display);
+    ((CButton*)GetDlgItem(IDC_SEPARATE_VALUE_UNIT_CHECK))->SetCheck(m_data.IsSeparateValueUnitWithSpaceForDisplay(0));
+    ((CButton*)GetDlgItem(IDC_SHOW_TOOL_TIP_CHK))->SetCheck(m_data.IsShowToolTipForDisplay(0));
 
     m_text_color_static.SetLinkCursor();
     m_back_color_static.SetLinkCursor();
@@ -329,6 +428,7 @@ BOOL CTaskBarSettingsDlg::OnInitDialog()
     m_toolTip.AddTool(&m_atuo_adapt_light_theme_chk, CCommon::LoadText(IDS_AUTO_ADAPT_TIP_INFO));
     m_toolTip.AddTool(GetDlgItem(IDC_SHOW_STATUS_BAR_CHECK), CCommon::LoadText(IDS_SHOW_RESOURCE_USAGE_GRAPH_TIP));
     m_toolTip.AddTool(GetDlgItem(IDC_SHOW_NET_SPEED_FIGURE_CHECK), CCommon::LoadText(IDS_SHOW_NET_SPEED_GRAPH_TIP));
+    m_toolTip.AddTool(GetDlgItem(IDC_WIN11_SETTINGS_BUTTON), _T(""));
 
 
     if (m_data.unit_byte)
@@ -346,6 +446,7 @@ BOOL CTaskBarSettingsDlg::OnInitDialog()
         m_hide_unit_chk.EnableWindow(FALSE);
     }
     ((CButton*)GetDlgItem(IDC_HIDE_PERCENTAGE_CHECK))->SetCheck(m_data.hide_percent);
+
     ((CButton*)GetDlgItem(IDC_SPECIFY_EACH_ITEM_COLOR_CHECK))->SetCheck(m_data.specify_each_item_color);
     m_background_transparent_chk.SetCheck(m_data.IsTaskbarTransparent());
     m_atuo_adapt_light_theme_chk.SetCheck(m_data.auto_adapt_light_theme);
@@ -367,12 +468,14 @@ BOOL CTaskBarSettingsDlg::OnInitDialog()
     m_double_click_combo.AddString(CCommon::LoadText(IDS_NONE));
     m_double_click_combo.SetCurSel(static_cast<int>(m_data.double_click_action));
 
+    ShowDlgCtrl(IDC_LAYOUT_SETTINGS_FOR_DISPLAY_STATIC, false);
+
     m_digit_number_combo.AddString(_T("3"));
     m_digit_number_combo.AddString(_T("4"));
     m_digit_number_combo.AddString(_T("5"));
     m_digit_number_combo.AddString(_T("6"));
     m_digit_number_combo.AddString(_T("7"));
-    m_digit_number_combo.SetCurSel(m_data.digits_number - 3);
+    m_digit_number_combo.SetCurSel(m_data.GetDigitsNumberForDisplay(0) - 3);
 
     SetDlgItemText(IDC_EXE_PATH_EDIT, m_data.double_click_exe.c_str());
 
@@ -386,10 +489,8 @@ BOOL CTaskBarSettingsDlg::OnInitDialog()
     CheckDlgButton(IDC_USAGE_GRAPH_FOLLOW_SYSTEM_CHECK, m_data.graph_color_following_system);
 
     m_item_space_edit.SetRange(0, 32);
-    m_item_space_edit.SetValue(m_data.item_space);
     CTaskBarDlg* taskbar_dlg{ CTrafficMonitorDlg::Instance()->GetTaskbarWindow() };
     m_vertical_margin_edit.SetRange(-10, 10);
-    m_vertical_margin_edit.SetValue(m_data.vertical_margin);
     if (taskbar_dlg != nullptr)
         m_vertical_margin_edit.EnableWindow(taskbar_dlg->IsTasksbarOnTopOrBottom());
 
@@ -397,7 +498,7 @@ BOOL CTaskBarSettingsDlg::OnInitDialog()
     m_memory_display_combo.AddString(CCommon::LoadText(IDS_USAGE_PERCENTAGE));
     m_memory_display_combo.AddString(CCommon::LoadText(IDS_MEMORY_USED));
     m_memory_display_combo.AddString(CCommon::LoadText(IDS_MEMORY_AVAILABLE));
-    m_memory_display_combo.SetCurSel(static_cast<int>(m_data.memory_display));
+    m_memory_display_combo.SetCurSel(static_cast<int>(m_data.GetMemoryDisplayForDisplay(0)));
 
     CheckDlgButton(IDC_SHOW_NET_SPEED_FIGURE_CHECK, m_data.show_netspeed_figure);
     m_net_speed_figure_max_val_edit.SetRange(1, 1024);
@@ -419,29 +520,52 @@ BOOL CTaskBarSettingsDlg::OnInitDialog()
         m_modify_default_style_menu.AppendMenu(MF_STRING | MF_ENABLED, ID_MODIFY_DEFAULT_STYLE1 + i, item_name);
     }
     m_default_style_menu.AppendMenu(MF_SEPARATOR);
-    m_default_style_menu.AppendMenu(MF_POPUP | MF_STRING, (UINT)m_modify_default_style_menu.m_hMenu, CCommon::LoadText(IDS_MODIFY_PRESET));
+    m_default_style_menu.AppendMenu(MF_POPUP | MF_STRING, reinterpret_cast<UINT_PTR>(m_modify_default_style_menu.m_hMenu), CCommon::LoadText(IDS_MODIFY_PRESET));
 
     //获取副显示器的数量
     std::vector<HWND> secondary_displays;
     CTaskbarHelper::GetAllSecondaryDisplayTaskbar(secondary_displays);
-    //初始化“显示任务栏窗口的显示器”下拉列表
-    m_displays_combo.AddString(CCommon::LoadText(IDS_PRIMARY_DISPLAY));
+    //初始化“显示任务栏窗口的显示器”列表
+    m_displays_list.ResetContent();
+    m_displays_list.SetCheckStyle(BS_AUTOCHECKBOX);
+    CString primary_display_text = CCommon::LoadText(IDS_PRIMARY_DISPLAY);
+    m_displays_list.AddString(primary_display_text);
     for (size_t i = 0; i < secondary_displays.size(); i++)
     {
-        m_displays_combo.AddString(CCommon::LoadTextFormat(IDS_SECONDARY_DISPLAY, { i + 1 }));
+        CString secondary_display_text = CCommon::LoadTextFormat(IDS_SECONDARY_DISPLAY, { i + 1 });
+        m_displays_list.AddString(secondary_display_text);
     }
-    if (!m_data.show_taskbar_wnd_in_secondary_display)
+
+    int display_count = m_displays_list.GetCount();
+
+    //为当前检测到的每个显示器初始化覆盖值，确保每个显示器设置独立。
+    for (int i = 0; i < display_count; i++)
     {
-        m_displays_combo.SetCurSel(0);
+        m_data.SetDisplayItemForDisplay(i, m_data.GetDisplayItemForDisplay(i));
+        m_data.SetSpeedShortModeForDisplay(i, m_data.IsSpeedShortModeForDisplay(i));
+        m_data.SetValueRightAlignForDisplay(i, m_data.IsValueRightAlignForDisplay(i));
+        m_data.SetHorizontalArrangeForDisplay(i, m_data.IsHorizontalArrangeForDisplay(i));
+        m_data.SetSeparateValueUnitWithSpaceForDisplay(i, m_data.IsSeparateValueUnitWithSpaceForDisplay(i));
+        m_data.SetShowToolTipForDisplay(i, m_data.IsShowToolTipForDisplay(i));
+        m_data.SetDigitsNumberForDisplay(i, m_data.GetDigitsNumberForDisplay(i));
+        m_data.SetMemoryDisplayForDisplay(i, m_data.GetMemoryDisplayForDisplay(i));
+        m_data.SetItemSpaceForDisplay(i, m_data.GetItemSpaceForDisplay(i));
+        m_data.SetVerticalMarginForDisplay(i, m_data.GetVerticalMarginForDisplay(i));
     }
-    else
+
+    for (int i = 0; i < display_count; i++)
+    {
+        bool checked = (m_data.taskbar_display_indices.find(i) != m_data.taskbar_display_indices.end());
+        m_displays_list.SetCheck(i, checked ? TRUE : FALSE);
+    }
+    UpdateTaskbarDisplaySelection();
+    if (display_count > 0)
     {
-        int combo_index = m_data.secondary_display_index + 1;
-        int combo_item_count = m_displays_combo.GetCount();
-        if (combo_index >= combo_item_count)
-            combo_index = combo_item_count - 1;
-        m_displays_combo.SetCurSel(combo_index);
+        m_current_display_index = 0;
+        m_displays_list.SetCurSel(0);
+        m_displays_list.SetCaretIndex(0);
     }
+    UpdatePerDisplayLayoutEditControls();
 
     //设置是否禁用D2D
     if (!CTaskBarDlgDrawCommonSupport::CheckSupport())
@@ -508,7 +632,10 @@ void CTaskBarSettingsDlg::OnBnClickedTaskbarWndOnLeftCheck()
 void CTaskBarSettingsDlg::OnBnClickedSpeedShortModeCheck()
 {
     // TODO: 在此添加控件通知处理程序代码
-    m_data.speed_short_mode = (((CButton*)GetDlgItem(IDC_SPEED_SHORT_MODE_CHECK))->GetCheck() != 0);
+    if (m_updating_per_display_controls)
+        return;
+    int display_index = GetCurrentDisplayIndex();
+    m_data.SetSpeedShortModeForDisplay(display_index, (((CButton*)GetDlgItem(IDC_SPEED_SHORT_MODE_CHECK))->GetCheck() != 0));
 }
 
 
@@ -586,7 +713,10 @@ void CTaskBarSettingsDlg::SaveColorSettingToDefaultStyle()
 void CTaskBarSettingsDlg::OnBnClickedValueRightAlignCheck()
 {
     // TODO: 在此添加控件通知处理程序代码
-    m_data.value_right_align = (((CButton*)GetDlgItem(IDC_VALUE_RIGHT_ALIGN_CHECK))->GetCheck() != 0);
+    if (m_updating_per_display_controls)
+        return;
+    int display_index = GetCurrentDisplayIndex();
+    m_data.SetValueRightAlignForDisplay(display_index, (((CButton*)GetDlgItem(IDC_VALUE_RIGHT_ALIGN_CHECK))->GetCheck() != 0));
 }
 
 
@@ -702,7 +832,10 @@ void CTaskBarSettingsDlg::OnCbnSelchangeDoubleClickCombo()
 void CTaskBarSettingsDlg::OnBnClickedHorizontalArrangeCheck()
 {
     // TODO: 在此添加控件通知处理程序代码
-    m_data.horizontal_arrange = (((CButton*)GetDlgItem(IDC_HORIZONTAL_ARRANGE_CHECK))->GetCheck() != 0);
+    if (m_updating_per_display_controls)
+        return;
+    int display_index = GetCurrentDisplayIndex();
+    m_data.SetHorizontalArrangeForDisplay(display_index, (((CButton*)GetDlgItem(IDC_HORIZONTAL_ARRANGE_CHECK))->GetCheck() != 0));
 }
 
 
@@ -717,7 +850,10 @@ void CTaskBarSettingsDlg::OnBnClickedShowStatusBarCheck()
 void CTaskBarSettingsDlg::OnBnClickedSeparateValueUnitCheck()
 {
     // TODO: 在此添加控件通知处理程序代码
-    m_data.separate_value_unit_with_space = (((CButton*)GetDlgItem(IDC_SEPARATE_VALUE_UNIT_CHECK))->GetCheck() != 0);
+    if (m_updating_per_display_controls)
+        return;
+    int display_index = GetCurrentDisplayIndex();
+    m_data.SetSeparateValueUnitWithSpaceForDisplay(display_index, (((CButton*)GetDlgItem(IDC_SEPARATE_VALUE_UNIT_CHECK))->GetCheck() != 0));
 }
 
 
@@ -740,7 +876,10 @@ void CTaskBarSettingsDlg::OnBnClickedUnitBitRadio()
 void CTaskBarSettingsDlg::OnBnClickedShowToolTipChk()
 {
     // TODO: 在此添加控件通知处理程序代码
-    m_data.show_tool_tip = (((CButton*)GetDlgItem(IDC_SHOW_TOOL_TIP_CHK))->GetCheck() != 0);
+    if (m_updating_per_display_controls)
+        return;
+    int display_index = GetCurrentDisplayIndex();
+    m_data.SetShowToolTipForDisplay(display_index, (((CButton*)GetDlgItem(IDC_SHOW_TOOL_TIP_CHK))->GetCheck() != 0));
 }
 
 
@@ -835,7 +974,10 @@ void CTaskBarSettingsDlg::OnBnClickedDisplayTextSettingButton()
 void CTaskBarSettingsDlg::OnCbnSelchangeMemoryDisplayCombo()
 {
     // TODO: 在此添加控件通知处理程序代码
-    m_data.memory_display = static_cast<MemoryDisplay>(m_memory_display_combo.GetCurSel());
+    if (m_updating_per_display_controls)
+        return;
+    int display_index = GetCurrentDisplayIndex();
+    m_data.SetMemoryDisplayForDisplay(display_index, static_cast<MemoryDisplay>(m_memory_display_combo.GetCurSel()));
 }
 
 
@@ -849,14 +991,15 @@ void CTaskBarSettingsDlg::OnBnClickedShowDashedBox()
 void CTaskBarSettingsDlg::OnBnClickedSetOrderButton()
 {
     // TODO: 在此添加控件通知处理程序代码
+    int display_index = GetCurrentDisplayIndex();
     CSetItemOrderDlg dlg;
     dlg.SetItemOrder(m_data.item_order.GetItemOrderConst());
-    dlg.SetDisplayItem(m_data.display_item);
+    dlg.SetDisplayItem(m_data.GetDisplayItemForDisplay(display_index));
     dlg.SetPluginDisplayItem(m_data.plugin_display_item);
     if (dlg.DoModal() == IDOK)
     {
         m_data.item_order.SetOrder(dlg.GetItemOrder());
-        m_data.display_item = dlg.GetDisplayItem();
+        m_data.SetDisplayItemForDisplay(display_index, dlg.GetDisplayItem());
         m_data.plugin_display_item = dlg.GetPluginDisplayItem();
     }
 }
@@ -870,14 +1013,18 @@ void CTaskBarSettingsDlg::OnEnChangeItemSpaceEdit()
     // 同时将 ENM_CHANGE 标志“或”运算到掩码中。
 
     // TODO:  在此添加控件通知处理程序代码
-    m_data.item_space = m_item_space_edit.GetValue();
-    m_data.ValidItemSpace();
+    if (m_updating_per_display_controls)
+        return;
+    int display_index = GetCurrentDisplayIndex();
+    m_data.SetItemSpaceForDisplay(display_index, m_item_space_edit.GetValue());
 }
 
 void CTaskBarSettingsDlg::OnEnChangeVerticalMarginEdit()
 {
-    m_data.vertical_margin = m_vertical_margin_edit.GetValue();
-    m_data.ValidVerticalMargin();
+    if (m_updating_per_display_controls)
+        return;
+    int display_index = GetCurrentDisplayIndex();
+    m_data.SetVerticalMarginForDisplay(display_index, m_vertical_margin_edit.GetValue());
 }
 
 BOOL CTaskBarSettingsDlg::OnCommand(WPARAM wParam, LPARAM lParam)
@@ -945,37 +1092,41 @@ void CTaskBarSettingsDlg::OnBnClickedEnableColorEmojiCheck()
 void CTaskBarSettingsDlg::OnCbnSelchangeDigitNumberCombo()
 {
     //获取数据位数的设置
-    m_data.digits_number = m_digit_number_combo.GetCurSel() + 3;
+    if (m_updating_per_display_controls)
+        return;
+    int display_index = GetCurrentDisplayIndex();
+    m_data.SetDigitsNumberForDisplay(display_index, m_digit_number_combo.GetCurSel() + 3);
 }
 
 
 void CTaskBarSettingsDlg::OnBnClickedWin11SettingsButton()
 {
-    CWin11TaskbarSettingDlg dlg(m_data);
+    CWin11TaskbarSettingDlg dlg(m_data, GetCurrentDisplayIndex());
     dlg.DoModal();
 }
 
 
-void CTaskBarSettingsDlg::OnBnClickedTaskbarWndInSecondaryDisplayCheck()
+void CTaskBarSettingsDlg::OnLbnSelchangeDisplayToShowTaskbarWndList()
 {
-    m_data.show_taskbar_wnd_in_secondary_display = (IsDlgButtonChecked(IDC_TASKBAR_WND_IN_SECONDARY_DISPLAY_CHECK) != FALSE);
-}
+    UpdateTaskbarDisplaySelection();
 
+    int item_count = m_displays_list.GetCount();
+    int display_index = m_displays_list.GetCurSel();
+    if (display_index == LB_ERR)
+        display_index = m_displays_list.GetCaretIndex();
 
-void CTaskBarSettingsDlg::OnCbnSelchangeDisplayToShowTaskbarWndCombo()
-{
-    
-    int combo_index = m_displays_combo.GetCurSel();
-    if (combo_index == 0)
-    {
-        m_data.show_taskbar_wnd_in_secondary_display = false;
-    }
-    else
-    {
-        m_data.show_taskbar_wnd_in_secondary_display = true;
-        m_data.secondary_display_index = combo_index - 1;
+    if (display_index == LB_ERR && m_current_display_index >= 0 && m_current_display_index < item_count)
+        display_index = m_current_display_index;
+    if (display_index == LB_ERR)
+        display_index = 0;
 
+    if (item_count > 0)
+    {
+        m_current_display_index = display_index;
+        m_displays_list.SetCurSel(display_index);
+        m_displays_list.SetCaretIndex(display_index);
     }
+    UpdatePerDisplayLayoutEditControls();
 }
 
 
diff --git a/TrafficMonitor/TaskBarSettingsDlg.h b/TrafficMonitor/TaskBarSettingsDlg.h
index 84847e242..2c9f563eb 100644
--- a/TrafficMonitor/TaskBarSettingsDlg.h
+++ b/TrafficMonitor/TaskBarSettingsDlg.h
@@ -1,6 +1,7 @@
 #pragma once
 #include "ColorStatic.h"
 #include "afxwin.h"
+#include "afxcmn.h"
 #include "SpinEdit.h"
 #include "TabDlg.h"
 #include "TaskbarColorDlg.h"
@@ -53,13 +54,21 @@ class CTaskBarSettingsDlg : public CTabDlg
     CSpinEdit m_vertical_margin_edit;
     CSpinEdit m_net_speed_figure_max_val_edit;
     CComboBox2 m_net_speed_figure_max_val_unit_combo;
-    CComboBox2 m_displays_combo;
+    CCheckListBox m_displays_list;
+    CString m_win11_settings_button_text;
+    CString m_layout_settings_prefix_text;
+    bool m_updating_per_display_controls{};
+    int m_current_display_index{};
 
     bool m_style_modified{};
 
 protected:
     void DrawStaticColor();
     void IniUnitCombo();
+    int GetCurrentDisplayIndex();
+    CString GetDisplayNameText(int display_index) const;
+    void UpdateTaskbarDisplaySelection();
+    void UpdatePerDisplayLayoutEditControls();
 
     void ApplyDefaultStyle(int index);      //应用一个预设方案
 
@@ -120,8 +129,7 @@ class CTaskBarSettingsDlg : public CTabDlg
     afx_msg void OnBnClickedEnableColorEmojiCheck();
     afx_msg void OnCbnSelchangeDigitNumberCombo();
     afx_msg void OnBnClickedWin11SettingsButton();
-    afx_msg void OnBnClickedTaskbarWndInSecondaryDisplayCheck();
-    afx_msg void OnCbnSelchangeDisplayToShowTaskbarWndCombo();
+    afx_msg void OnLbnSelchangeDisplayToShowTaskbarWndList();
     afx_msg void OnBnClickedUsageGraphFollowSystemCheck();
     afx_msg void OnEnChangeFontSizeEdit1();
 };
diff --git a/TrafficMonitor/TrafficMonitor.cpp b/TrafficMonitor/TrafficMonitor.cpp
index 17b32cb5e..c298b17de 100644
--- a/TrafficMonitor/TrafficMonitor.cpp
+++ b/TrafficMonitor/TrafficMonitor.cpp
@@ -171,8 +171,40 @@ void CTrafficMonitorApp::LoadConfig()
     m_taskbar_data.specify_each_item_color = ini.GetBool(L"task_bar", L"specify_each_item_color", false);
     //m_cfg_data.m_tbar_show_cpu_memory = ini.GetBool(_T("task_bar"), _T("task_bar_show_cpu_memory"), false);
     m_taskbar_data.display_item.FromInt(ini.GetInt(L"task_bar", L"tbar_display_item", DisplayItemSet{ TDI_UP, TDI_DOWN }.ToInt()));
-    m_taskbar_data.show_taskbar_wnd_in_secondary_display = ini.GetBool(L"task_bar", L"show_taskbar_wnd_in_secondary_display", false);
-    m_taskbar_data.secondary_display_index = ini.GetInt(L"task_bar", L"secondary_display_index", 0);
+    m_taskbar_data.taskbar_display_indices.clear();
+    std::wstring taskbar_display_indices_str = ini.GetString(L"task_bar", L"taskbar_display_indices", L"");
+    if (taskbar_display_indices_str.empty())
+    {
+        //兼容旧版本配置：主显示器/副显示器/主+副
+        bool show_taskbar_wnd_in_secondary_display = ini.GetBool(L"task_bar", L"show_taskbar_wnd_in_secondary_display", false);
+        bool show_taskbar_wnd_in_both_displays = ini.GetBool(L"task_bar", L"show_taskbar_wnd_in_both_displays", false);
+        int secondary_display_index = ini.GetInt(L"task_bar", L"secondary_display_index", 0);
+        if (secondary_display_index < 0)
+            secondary_display_index = 0;
+
+        if (!show_taskbar_wnd_in_secondary_display)
+            m_taskbar_data.taskbar_display_indices.insert(0);
+        else if (show_taskbar_wnd_in_both_displays)
+        {
+            m_taskbar_data.taskbar_display_indices.insert(0);
+            m_taskbar_data.taskbar_display_indices.insert(secondary_display_index + 1);
+        }
+        else
+            m_taskbar_data.taskbar_display_indices.insert(secondary_display_index + 1);
+    }
+    else
+    {
+        std::vector<std::wstring> display_index_str_list;
+        CCommon::StringSplit(taskbar_display_indices_str, L',', display_index_str_list);
+        for (const auto& display_index_str : display_index_str_list)
+        {
+            int display_index = _wtoi(display_index_str.c_str());
+            if (display_index >= 0)
+                m_taskbar_data.taskbar_display_indices.insert(display_index);
+        }
+    }
+    if (m_taskbar_data.taskbar_display_indices.empty())
+        m_taskbar_data.taskbar_display_indices.insert(0);
 
     //不含温度监控的版本，不显示温度监控相关项目
 #ifdef WITHOUT_TEMPERATURE
@@ -235,11 +267,112 @@ void CTrafficMonitorApp::LoadConfig()
     m_taskbar_data.vertical_margin = ini.GetInt(L"task_bar", L"vertical_margin", 0);
     m_taskbar_data.window_offset_top = ini.GetInt(L"task_bar", L"window_offset_top", 0);
     m_taskbar_data.window_offset_left = ini.GetInt(L"task_bar", L"window_offset_left", 0);
+    m_taskbar_data.avoid_overlap_with_widgets = ini.GetBool(_T("task_bar"), _T("avoid_overlap_with_widgets"), false);
+    m_taskbar_data.taskbar_left_space_win11 = ini.GetInt(L"task_bar", L"taskbar_left_space_win11", 160);
+
+    auto parse_display_value_map = [&](const std::wstring& config_value, std::map<int, int>& value_map, int min_value, int max_value)
+    {
+        value_map.clear();
+        if (config_value.empty())
+            return;
+
+        std::vector<std::wstring> parts;
+        CCommon::StringSplit(config_value, L',', parts);
+        for (const auto& part : parts)
+        {
+            size_t separator_index = part.find(L':');
+            if (separator_index == std::wstring::npos)
+                continue;
+
+            std::wstring display_index_str = part.substr(0, separator_index);
+            std::wstring value_str = part.substr(separator_index + 1);
+            int display_index = _wtoi(display_index_str.c_str());
+            int value = _wtoi(value_str.c_str());
+            if (display_index < 0)
+                continue;
+            if (value < min_value)
+                value = min_value;
+            if (value > max_value)
+                value = max_value;
+            value_map[display_index] = value;
+        }
+    };
+
+    auto parse_display_bool_map = [&](const std::wstring& config_value, std::map<int, bool>& value_map)
+    {
+        value_map.clear();
+        if (config_value.empty())
+            return;
+
+        std::vector<std::wstring> parts;
+        CCommon::StringSplit(config_value, L',', parts);
+        for (const auto& part : parts)
+        {
+            size_t separator_index = part.find(L':');
+            if (separator_index == std::wstring::npos)
+                continue;
+
+            std::wstring display_index_str = part.substr(0, separator_index);
+            std::wstring value_str = part.substr(separator_index + 1);
+            int display_index = _wtoi(display_index_str.c_str());
+            if (display_index < 0)
+                continue;
+            value_map[display_index] = (_wtoi(value_str.c_str()) != 0);
+        }
+    };
+
+    parse_display_value_map(ini.GetString(L"task_bar", L"item_space_per_display", L""), m_taskbar_data.item_space_per_display, 0, 32);
+    parse_display_value_map(ini.GetString(L"task_bar", L"vertical_margin_per_display", L""), m_taskbar_data.vertical_margin_per_display, -10, 10);
+    parse_display_value_map(ini.GetString(L"task_bar", L"window_offset_top_per_display", L""), m_taskbar_data.window_offset_top_per_display, -20, 20);
+    parse_display_value_map(ini.GetString(L"task_bar", L"window_offset_left_per_display", L""), m_taskbar_data.window_offset_left_per_display, -800, 800);
+    parse_display_bool_map(ini.GetString(L"task_bar", L"task_bar_wnd_snap_per_display", L""), m_taskbar_data.tbar_wnd_snap_per_display);
+    parse_display_bool_map(ini.GetString(L"task_bar", L"avoid_overlap_with_widgets_per_display", L""), m_taskbar_data.avoid_overlap_with_widgets_per_display);
+    parse_display_value_map(ini.GetString(L"task_bar", L"taskbar_left_space_win11_per_display", L""), m_taskbar_data.taskbar_left_space_win11_per_display, 0, 300);
+    parse_display_bool_map(ini.GetString(L"task_bar", L"task_bar_speed_short_mode_per_display", L""), m_taskbar_data.speed_short_mode_per_display);
+    parse_display_bool_map(ini.GetString(L"task_bar", L"value_right_align_per_display", L""), m_taskbar_data.value_right_align_per_display);
+    parse_display_value_map(ini.GetString(L"task_bar", L"digits_number_per_display", L""), m_taskbar_data.digits_number_per_display, 3, 7);
+    parse_display_bool_map(ini.GetString(L"task_bar", L"horizontal_arrange_per_display", L""), m_taskbar_data.horizontal_arrange_per_display);
+    parse_display_bool_map(ini.GetString(L"task_bar", L"separate_value_unit_with_space_per_display", L""), m_taskbar_data.separate_value_unit_with_space_per_display);
+    parse_display_bool_map(ini.GetString(L"task_bar", L"show_tool_tip_per_display", L""), m_taskbar_data.show_tool_tip_per_display);
+    parse_display_value_map(ini.GetString(L"task_bar", L"memory_display_per_display", L""), m_taskbar_data.memory_display_per_display,
+        static_cast<int>(MemoryDisplay::USAGE_PERCENTAGE), static_cast<int>(MemoryDisplay::MEMORY_AVAILABLE));
+    parse_display_value_map(ini.GetString(L"task_bar", L"display_item_per_display", L""), m_taskbar_data.display_item_per_display, 0, 0x7fffffff);
+
+    auto sanitize_display_item_set = [&]()
+    {
+        auto apply_filter = [&](DisplayItemSet& display_item_set)
+        {
+#ifdef WITHOUT_TEMPERATURE
+            display_item_set.Remove(TDI_CPU_TEMP);
+            display_item_set.Remove(TDI_GPU_TEMP);
+            display_item_set.Remove(TDI_HDD_TEMP);
+            display_item_set.Remove(TDI_MAIN_BOARD_TEMP);
+#endif
+            if (!m_general_data.IsHardwareEnable(HI_CPU))
+                display_item_set.Remove(TDI_CPU_TEMP);
+            if (!m_general_data.IsHardwareEnable(HI_GPU))
+                display_item_set.Remove(TDI_GPU_TEMP);
+            if (!m_general_data.IsHardwareEnable(HI_HDD))
+                display_item_set.Remove(TDI_HDD_TEMP);
+            if (!m_general_data.IsHardwareEnable(HI_MBD))
+                display_item_set.Remove(TDI_MAIN_BOARD_TEMP);
+        };
+
+        for (auto& item : m_taskbar_data.display_item_per_display)
+        {
+            DisplayItemSet display_item_set;
+            display_item_set.FromInt(item.second);
+            apply_filter(display_item_set);
+            item.second = display_item_set.ToInt();
+        }
+    };
+    sanitize_display_item_set();
+    m_taskbar_data.display_item = m_taskbar_data.GetDisplayItemForDisplay(0);
+
     m_taskbar_data.ValidItemSpace();
+    m_taskbar_data.ValidVerticalMargin();
     m_taskbar_data.ValidWindowOffsetTop();
     m_taskbar_data.ValidWindowOffsetLeft();
-    m_taskbar_data.avoid_overlap_with_widgets = ini.GetBool(_T("task_bar"), _T("avoid_overlap_with_widgets"), false);
-    m_taskbar_data.taskbar_left_space_win11 = ini.GetInt(L"task_bar", L"taskbar_left_space_win11", 160);
     m_taskbar_data.taskbar_right_space_win11 = ini.GetInt(L"task_bar", L"taskbar_right_space_win11", 280);
 
     if (m_win_version.IsWindows10OrLater())     //只有Win10才支持自动适应系统深色/浅色主题
@@ -364,6 +497,7 @@ void CTrafficMonitorApp::SaveConfig()
     ini.WriteInt(L"notify_tip", L"mainboard_temperature_tip_value", m_general_data.mainboard_temp_tip.tip_value);
 
     //任务栏窗口设置
+    m_taskbar_data.display_item = m_taskbar_data.GetDisplayItemForDisplay(0);
     ini.WriteInt(L"task_bar", L"task_bar_back_color", m_taskbar_data.back_color);
     ini.WriteInt(L"task_bar", L"transparent_color", m_taskbar_data.transparent_color);
     ini.WriteInt(L"task_bar", L"status_bar_color", m_taskbar_data.status_bar_color);
@@ -373,12 +507,49 @@ void CTrafficMonitorApp::SaveConfig()
     ini.WriteInt(L"task_bar", L"tbar_display_item", m_taskbar_data.display_item.ToInt());
     ini.SaveFontData(L"task_bar", m_taskbar_data.font);
     //ini.WriteBool(L"task_bar", L"task_bar_swap_up_down", m_taskbar_data.swap_up_down);
-    ini.WriteBool(L"task_bar", L"show_taskbar_wnd_in_secondary_display", m_taskbar_data.show_taskbar_wnd_in_secondary_display);
-    ini.WriteInt(L"task_bar", L"secondary_display_index", m_taskbar_data.secondary_display_index);
+    std::wstring taskbar_display_indices_str;
+    for (const auto& display_index : m_taskbar_data.taskbar_display_indices)
+    {
+        if (!taskbar_display_indices_str.empty())
+            taskbar_display_indices_str += L",";
+        taskbar_display_indices_str += std::to_wstring(display_index);
+    }
+    if (taskbar_display_indices_str.empty())
+        taskbar_display_indices_str = L"0";
+    ini.WriteString(L"task_bar", L"taskbar_display_indices", taskbar_display_indices_str);
+
+    //兼容旧版本配置
+    bool has_primary_display{ false };
+    int first_secondary_display_index{ -1 };
+    for (const auto& display_index : m_taskbar_data.taskbar_display_indices)
+    {
+        if (display_index == 0)
+            has_primary_display = true;
+        else if (display_index > 0 && first_secondary_display_index < 0)
+            first_secondary_display_index = display_index - 1;
+    }
+    bool show_taskbar_wnd_in_secondary_display = (first_secondary_display_index >= 0);
+    bool show_taskbar_wnd_in_both_displays = (show_taskbar_wnd_in_secondary_display && has_primary_display);
+    ini.WriteBool(L"task_bar", L"show_taskbar_wnd_in_secondary_display", show_taskbar_wnd_in_secondary_display);
+    ini.WriteBool(L"task_bar", L"show_taskbar_wnd_in_both_displays", show_taskbar_wnd_in_both_displays);
+    ini.WriteInt(L"task_bar", L"secondary_display_index", show_taskbar_wnd_in_secondary_display ? first_secondary_display_index : 0);
 
     ini.SaveDisplayStr(L"task_bar", m_taskbar_data.disp_str);
     ini.SavePluginDisplayStr(L"plugin_display_str_taskbar_window", m_taskbar_data.disp_str);
 
+    //保留旧配置字段并同步主显示器值，确保与旧版本兼容
+    m_taskbar_data.SetDisplayItemForDisplay(0, m_taskbar_data.display_item);
+    m_taskbar_data.tbar_wnd_snap = m_taskbar_data.IsTaskbarWndSnapForDisplay(0);
+    m_taskbar_data.avoid_overlap_with_widgets = m_taskbar_data.IsAvoidOverlapWithWidgetsForDisplay(0);
+    m_taskbar_data.taskbar_left_space_win11 = m_taskbar_data.GetTaskbarLeftSpaceForDisplay(0);
+    m_taskbar_data.speed_short_mode = m_taskbar_data.IsSpeedShortModeForDisplay(0);
+    m_taskbar_data.value_right_align = m_taskbar_data.IsValueRightAlignForDisplay(0);
+    m_taskbar_data.digits_number = m_taskbar_data.GetDigitsNumberForDisplay(0);
+    m_taskbar_data.horizontal_arrange = m_taskbar_data.IsHorizontalArrangeForDisplay(0);
+    m_taskbar_data.separate_value_unit_with_space = m_taskbar_data.IsSeparateValueUnitWithSpaceForDisplay(0);
+    m_taskbar_data.show_tool_tip = m_taskbar_data.IsShowToolTipForDisplay(0);
+    m_taskbar_data.memory_display = m_taskbar_data.GetMemoryDisplayForDisplay(0);
+
     ini.WriteBool(L"task_bar", L"task_bar_wnd_on_left", m_taskbar_data.tbar_wnd_on_left);
     ini.WriteBool(L"task_bar", L"task_bar_wnd_snap", m_taskbar_data.tbar_wnd_snap);
     ini.WriteBool(L"task_bar", L"task_bar_speed_short_mode", m_taskbar_data.speed_short_mode);
@@ -397,10 +568,66 @@ void CTrafficMonitorApp::SaveConfig()
     ini.WriteString(L"task_bar", L"double_click_exe", m_taskbar_data.double_click_exe);
     ini.WriteBool(L"task_bar", L"cm_graph_type", m_taskbar_data.cm_graph_type);
     ini.WriteBool(L"task_bar", L"show_graph_dashed_box", m_taskbar_data.show_graph_dashed_box);
+
+    //保留旧配置字段并同步主显示器值，确保与旧版本兼容
+    m_taskbar_data.item_space = m_taskbar_data.GetItemSpaceForDisplay(0);
+    m_taskbar_data.vertical_margin = m_taskbar_data.GetVerticalMarginForDisplay(0);
+    m_taskbar_data.window_offset_top = m_taskbar_data.GetWindowOffsetTopForDisplay(0);
+    m_taskbar_data.window_offset_left = m_taskbar_data.GetWindowOffsetLeftForDisplay(0);
+
     ini.WriteInt(L"task_bar", L"item_space", m_taskbar_data.item_space);
     ini.WriteInt(L"task_bar", L"vertical_margin", m_taskbar_data.vertical_margin);
     ini.WriteInt(L"task_bar", L"window_offset_top", m_taskbar_data.window_offset_top);
     ini.WriteInt(L"task_bar", L"window_offset_left", m_taskbar_data.window_offset_left);
+
+    auto serialize_display_value_map = [](const std::map<int, int>& value_map)
+    {
+        std::wstring config_value;
+        for (const auto& item : value_map)
+        {
+            if (item.first < 0)
+                continue;
+            if (!config_value.empty())
+                config_value += L",";
+            config_value += std::to_wstring(item.first);
+            config_value += L":";
+            config_value += std::to_wstring(item.second);
+        }
+        return config_value;
+    };
+
+    auto serialize_display_bool_map = [](const std::map<int, bool>& value_map)
+    {
+        std::wstring config_value;
+        for (const auto& item : value_map)
+        {
+            if (item.first < 0)
+                continue;
+            if (!config_value.empty())
+                config_value += L",";
+            config_value += std::to_wstring(item.first);
+            config_value += L":";
+            config_value += (item.second ? L"1" : L"0");
+        }
+        return config_value;
+    };
+
+    ini.WriteString(L"task_bar", L"item_space_per_display", serialize_display_value_map(m_taskbar_data.item_space_per_display));
+    ini.WriteString(L"task_bar", L"vertical_margin_per_display", serialize_display_value_map(m_taskbar_data.vertical_margin_per_display));
+    ini.WriteString(L"task_bar", L"window_offset_top_per_display", serialize_display_value_map(m_taskbar_data.window_offset_top_per_display));
+    ini.WriteString(L"task_bar", L"window_offset_left_per_display", serialize_display_value_map(m_taskbar_data.window_offset_left_per_display));
+    ini.WriteString(L"task_bar", L"task_bar_wnd_snap_per_display", serialize_display_bool_map(m_taskbar_data.tbar_wnd_snap_per_display));
+    ini.WriteString(L"task_bar", L"avoid_overlap_with_widgets_per_display", serialize_display_bool_map(m_taskbar_data.avoid_overlap_with_widgets_per_display));
+    ini.WriteString(L"task_bar", L"taskbar_left_space_win11_per_display", serialize_display_value_map(m_taskbar_data.taskbar_left_space_win11_per_display));
+    ini.WriteString(L"task_bar", L"task_bar_speed_short_mode_per_display", serialize_display_bool_map(m_taskbar_data.speed_short_mode_per_display));
+    ini.WriteString(L"task_bar", L"value_right_align_per_display", serialize_display_bool_map(m_taskbar_data.value_right_align_per_display));
+    ini.WriteString(L"task_bar", L"digits_number_per_display", serialize_display_value_map(m_taskbar_data.digits_number_per_display));
+    ini.WriteString(L"task_bar", L"horizontal_arrange_per_display", serialize_display_bool_map(m_taskbar_data.horizontal_arrange_per_display));
+    ini.WriteString(L"task_bar", L"separate_value_unit_with_space_per_display", serialize_display_bool_map(m_taskbar_data.separate_value_unit_with_space_per_display));
+    ini.WriteString(L"task_bar", L"show_tool_tip_per_display", serialize_display_bool_map(m_taskbar_data.show_tool_tip_per_display));
+    ini.WriteString(L"task_bar", L"memory_display_per_display", serialize_display_value_map(m_taskbar_data.memory_display_per_display));
+    ini.WriteString(L"task_bar", L"display_item_per_display", serialize_display_value_map(m_taskbar_data.display_item_per_display));
+
     ini.WriteBool(L"task_bar", L"avoid_overlap_with_widgets", m_taskbar_data.avoid_overlap_with_widgets);
     ini.WriteInt(L"task_bar", L"taskbar_left_space_win11", m_taskbar_data.taskbar_left_space_win11);
     ini.WriteInt(L"task_bar", L"taskbar_right_space_win11", m_taskbar_data.taskbar_right_space_win11);
@@ -795,7 +1022,7 @@ void CTrafficMonitorApp::InitMenuResourse()
     CMenuIcon::AddIconToMenuItem(m_main_menu_plugin_sub_menu.GetSafeHmenu(), ID_PLUGIN_DETAIL, FALSE, GetMenuIcon(IDI_INFO));
     CMenu* main_menu_plugin = m_main_menu_plugin.GetSubMenu(0);
     main_menu_plugin->AppendMenu(MF_SEPARATOR);
-    main_menu_plugin->AppendMenu(MF_POPUP | MF_STRING, (UINT)m_main_menu_plugin_sub_menu.m_hMenu, _T("<plugin name>"));
+    main_menu_plugin->AppendMenu(MF_POPUP | MF_STRING, reinterpret_cast<UINT_PTR>(m_main_menu_plugin_sub_menu.m_hMenu), _T("<plugin name>"));
 
     m_taskbar_menu_plugin_sub_menu.CreatePopupMenu();
     m_taskbar_menu_plugin_sub_menu.AppendMenu(MF_STRING | MF_ENABLED, ID_PLUGIN_OPTIONS_TASKBAR, CCommon::LoadText(IDS_PLUGIN_OPTIONS, _T("...")));
@@ -804,7 +1031,7 @@ void CTrafficMonitorApp::InitMenuResourse()
     CMenuIcon::AddIconToMenuItem(m_taskbar_menu_plugin_sub_menu.GetSafeHmenu(), ID_PLUGIN_DETAIL_TASKBAR, FALSE, GetMenuIcon(IDI_INFO));
     CMenu* taskbar_menu_plugin = m_taskbar_menu_plugin.GetSubMenu(0);
     taskbar_menu_plugin->AppendMenu(MF_SEPARATOR);
-    taskbar_menu_plugin->AppendMenu(MF_POPUP | MF_STRING, (UINT)m_taskbar_menu_plugin_sub_menu.m_hMenu, _T("<plugin name>"));
+    taskbar_menu_plugin->AppendMenu(MF_POPUP | MF_STRING, reinterpret_cast<UINT_PTR>(m_taskbar_menu_plugin_sub_menu.m_hMenu), _T("<plugin name>"));
 
     //为菜单项添加图标
     auto addIconsForMainWindowMenu = [&](const CMenu& menu)
diff --git a/TrafficMonitor/TrafficMonitor.rc b/TrafficMonitor/TrafficMonitor.rc
index d47601cd6..d41065ced 100644
Binary files a/TrafficMonitor/TrafficMonitor.rc and b/TrafficMonitor/TrafficMonitor.rc differ
diff --git a/TrafficMonitor/TrafficMonitorDlg.cpp b/TrafficMonitor/TrafficMonitorDlg.cpp
index e7952e9df..d5ffec2f1 100644
--- a/TrafficMonitor/TrafficMonitorDlg.cpp
+++ b/TrafficMonitor/TrafficMonitorDlg.cpp
@@ -18,6 +18,8 @@
 #include "WineTaskbarDlg.h"
 #include "TaskbarHelper.h"
 #include "SkinManager.h"
+#include <algorithm>
+#include <set>
 
 #ifdef _DEBUG
 #define new DEBUG_NEW
@@ -41,21 +43,17 @@ CTrafficMonitorDlg::~CTrafficMonitorDlg()
 {
     free(m_pIfTable);
 
-    if (m_tBarDlg != nullptr)
-    {
-        delete m_tBarDlg;
-        m_tBarDlg = nullptr;
-    }
-
     ::ReleaseDC(NULL, m_desktop_dc);
 }
 
 CTaskBarDlg* CTrafficMonitorDlg::GetTaskbarWindow() const
 {
-    if (IsTaskbarWndValid())
-        return m_tBarDlg;
-    else
-        return nullptr;
+    for (const auto& taskbar_wnd : m_taskbar_windows)
+    {
+        if (IsTaskbarWndValid(taskbar_wnd.get()))
+            return taskbar_wnd.get();
+    }
+    return nullptr;
 }
 
 CTrafficMonitorDlg* CTrafficMonitorDlg::Instance()
@@ -553,26 +551,73 @@ void CTrafficMonitorDlg::SetConnectionMenuState(CMenu* pMenu)
 
 void CTrafficMonitorDlg::CloseTaskBarWnd()
 {
-    if (m_tBarDlg != nullptr)
+    for (auto& taskbar_wnd : m_taskbar_windows)
     {
-        if (IsTaskbarWndValid())
-            m_tBarDlg->OnCancel();
-        delete m_tBarDlg;
-        m_tBarDlg = nullptr;
-        theApp.m_taskbar_data.update_layered_window_error_code = 0;
+        CloseSingleTaskBarWnd(taskbar_wnd);
     }
+    m_taskbar_windows.clear();
+    m_taskbar_menu_invoker = nullptr;
+    theApp.m_taskbar_data.update_layered_window_error_code = 0;
 }
 
-void CTrafficMonitorDlg::OpenTaskBarWnd()
+void CTrafficMonitorDlg::CloseSingleTaskBarWnd(std::unique_ptr<CTaskBarDlg>& taskbar_wnd)
 {
-    // 强制初始化theApp.m_is_windows11_taskbar的值
-    theApp.CheckWindows11Taskbar();
+    if (taskbar_wnd != nullptr)
+    {
+        if (m_taskbar_menu_invoker == taskbar_wnd.get())
+            m_taskbar_menu_invoker = nullptr;
+        if (IsTaskbarWndValid(taskbar_wnd.get()))
+            taskbar_wnd->OnCancel();
+        taskbar_wnd.reset();
+    }
+}
+
+std::vector<CTrafficMonitorDlg::TaskbarWndTarget> CTrafficMonitorDlg::BuildTaskbarWndTargets() const
+{
+    std::vector<TaskbarWndTarget> targets;
+
+    std::set<int> display_indices = theApp.m_taskbar_data.taskbar_display_indices;
+    if (display_indices.empty())
+        display_indices.insert(0);
+
+    bool can_show_secondary_display = CWindowsSettingHelper::IsTaskbarShowingInAllDisplays();
+    int secondary_display_num = (can_show_secondary_display ? CTaskbarHelper::GetSecondaryTaskbarNum() : 0);
+
+    for (const auto& display_index : display_indices)
+    {
+        if (display_index == 0)
+        {
+            targets.push_back({ CTaskBarDlg::DisplayTarget::PRIMARY_DISPLAY, 0 });
+        }
+        else if (display_index > 0 && can_show_secondary_display)
+        {
+            int secondary_display_index = display_index - 1;
+            if (secondary_display_index >= 0 && secondary_display_index < secondary_display_num)
+                targets.push_back({ CTaskBarDlg::DisplayTarget::SECONDARY_DISPLAY, secondary_display_index });
+        }
+    }
+
+    if (targets.empty())
+        targets.push_back({ CTaskBarDlg::DisplayTarget::PRIMARY_DISPLAY, 0 });
+
+    return targets;
+}
+
+void CTrafficMonitorDlg::OpenSingleTaskBarWnd(std::unique_ptr<CTaskBarDlg>& taskbar_wnd, const TaskbarWndTarget& target)
+{
+    if (taskbar_wnd != nullptr)
+        return;
+
+    std::unique_ptr<CTaskBarDlg> taskbar_wnd_tmp;
+
     if (theApp.m_win_version.IsWine())
-        m_tBarDlg = new CWineTaskbarDlg();
+        taskbar_wnd_tmp = std::make_unique<CWineTaskbarDlg>();
     else if (theApp.IsWindows11Taskbar())
-        m_tBarDlg = new CWin11TaskbarDlg();
+        taskbar_wnd_tmp = std::make_unique<CWin11TaskbarDlg>();
     else
-        m_tBarDlg = new CClassicalTaskbarDlg();
+        taskbar_wnd_tmp = std::make_unique<CClassicalTaskbarDlg>();
+
+    taskbar_wnd_tmp->SetDisplayTarget(target.display_target, target.secondary_display_index);
 
     CSupportedRenderEnums supported_render_enums{};
     CTaskBarDlg::DisableRenderFeatureIfNecessary(supported_render_enums);
@@ -580,20 +625,54 @@ void CTrafficMonitorDlg::OpenTaskBarWnd()
     // WS_EX_LAYERED 和 WS_EX_NOREDIRECTIONBITMAP 可以共存，见微软示例代码
     // https://github.com/microsoft/Windows-classic-samples/blob/7cbd99ac1d2b4a0beffbaba29ea63d024ceff700/Samples/DynamicDPI/cpp/SampleDesktopWindow.cpp#L179
     // 但是WS_EX_NOREDIRECTIONBITMAP似乎会导致UpdateLayeredWindowIndirect失败
+    BOOL create_rtn{};
     switch (render_type)
     {
         using namespace DrawCommonHelper;
     case RenderType::D2D1_WITH_DCOMPOSITION:
-        m_tBarDlg->Create(IDD_TASK_BAR_DIALOG_NOREDIRECTIONBITMAP, this);
+        create_rtn = taskbar_wnd_tmp->Create(IDD_TASK_BAR_DIALOG_NOREDIRECTIONBITMAP, this);
         break;
     // 包括RenderType::D2D1在内的其他值
     default:
-        m_tBarDlg->Create(IDD_TASK_BAR_DIALOG, this);
+        create_rtn = taskbar_wnd_tmp->Create(IDD_TASK_BAR_DIALOG, this);
         break;
     }
-    m_tBarDlg->ShowWindow(SW_SHOW);
-    //m_tBarDlg->ShowInfo();
-    //IniTaskBarConnectionMenu();
+
+    if (!create_rtn)
+        return;
+
+    taskbar_wnd_tmp->ShowWindow(SW_SHOW);
+    taskbar_wnd = std::move(taskbar_wnd_tmp);
+}
+
+void CTrafficMonitorDlg::ForEachTaskbarWnd(const std::function<void(CTaskBarDlg*)>& fn)
+{
+    for (auto& taskbar_wnd : m_taskbar_windows)
+    {
+        if (IsTaskbarWndValid(taskbar_wnd.get()))
+            fn(taskbar_wnd.get());
+    }
+}
+
+void CTrafficMonitorDlg::OpenTaskBarWnd()
+{
+    // 强制初始化theApp.m_is_windows11_taskbar的值
+    theApp.CheckWindows11Taskbar();
+
+    CloseTaskBarWnd();
+
+    auto targets = BuildTaskbarWndTargets();
+    for (const auto& target : targets)
+    {
+        m_taskbar_windows.emplace_back();
+        OpenSingleTaskBarWnd(m_taskbar_windows.back(), target);
+    }
+
+    m_taskbar_windows.erase(std::remove_if(m_taskbar_windows.begin(), m_taskbar_windows.end(),
+        [](const std::unique_ptr<CTaskBarDlg>& taskbar_wnd)
+        {
+            return taskbar_wnd == nullptr;
+        }), m_taskbar_windows.end());
 }
 
 void CTrafficMonitorDlg::AddNotifyIcon()
@@ -743,8 +822,7 @@ void CTrafficMonitorDlg::ApplySettings(COptionsDlg& optionsDlg)
     bool is_connections_hide_changed = (optionsDlg.m_tab3_dlg.m_data.connections_hide.data() != theApp.m_general_data.connections_hide.data());
     bool d2d_turned_on = (theApp.m_taskbar_data.disable_d2d && !optionsDlg.m_tab2_dlg.m_data.disable_d2d);
     //需要重新关闭再打开任务栏窗口的情况
-    bool taskbar_changed = (theApp.m_taskbar_data.show_taskbar_wnd_in_secondary_display != optionsDlg.m_tab2_dlg.m_data.show_taskbar_wnd_in_secondary_display
-        || theApp.m_taskbar_data.secondary_display_index != optionsDlg.m_tab2_dlg.m_data.secondary_display_index
+    bool taskbar_changed = (theApp.m_taskbar_data.taskbar_display_indices != optionsDlg.m_tab2_dlg.m_data.taskbar_display_indices
         || theApp.m_taskbar_data.disable_d2d != optionsDlg.m_tab2_dlg.m_data.disable_d2d
         || theApp.m_taskbar_data.IsTaskbarTransparent() != optionsDlg.m_tab2_dlg.m_data.IsTaskbarTransparent()
         || theApp.m_taskbar_data.auto_set_background_color != optionsDlg.m_tab2_dlg.m_data.auto_set_background_color
@@ -770,7 +848,6 @@ void CTrafficMonitorDlg::ApplySettings(COptionsDlg& optionsDlg)
     //CTaskBarDlg::SaveConfig();
     if (IsTaskbarWndValid())
     {
-        m_tBarDlg->ApplySettings();
         //如果更改了任务栏窗口字体或显示的文本，则任务栏窗口可能要变化，于是关闭再打开任务栏窗口
         if (taskbar_changed)
         {
@@ -779,9 +856,13 @@ void CTrafficMonitorDlg::ApplySettings(COptionsDlg& optionsDlg)
         }
         else
         {
-            m_tBarDlg->WidthChanged();
+            ForEachTaskbarWnd([](CTaskBarDlg* taskbar_wnd)
+            {
+                taskbar_wnd->ApplySettings();
+                taskbar_wnd->WidthChanged();
+                taskbar_wnd->ApplyWindowTransparentColor();
+            });
         }
-        m_tBarDlg->ApplyWindowTransparentColor();
     }
 
     if (optionsDlg.m_tab3_dlg.IsAutoRunModified())
@@ -934,7 +1015,24 @@ void CTrafficMonitorDlg::SetTextFont()
 
 bool CTrafficMonitorDlg::IsTaskbarWndValid() const
 {
-    return m_tBarDlg != nullptr && ::IsWindow(m_tBarDlg->GetSafeHwnd());
+    for (const auto& taskbar_wnd : m_taskbar_windows)
+    {
+        if (IsTaskbarWndValid(taskbar_wnd.get()))
+            return true;
+    }
+    return false;
+}
+
+bool CTrafficMonitorDlg::IsTaskbarWndValid(const CTaskBarDlg* taskbar_wnd) const
+{
+    return taskbar_wnd != nullptr && ::IsWindow(taskbar_wnd->GetSafeHwnd());
+}
+
+CTaskBarDlg* CTrafficMonitorDlg::GetTaskbarWndForMenuCommand() const
+{
+    if (IsTaskbarWndValid(m_taskbar_menu_invoker))
+        return m_taskbar_menu_invoker;
+    return GetTaskbarWindow();
 }
 
 void CTrafficMonitorDlg::TaskbarShowHideItem(DisplayItem type)
@@ -952,7 +1050,7 @@ void CTrafficMonitorDlg::TaskbarShowHideItem(DisplayItem type)
         }
         //CloseTaskBarWnd();
         //OpenTaskBarWnd();
-        m_tBarDlg->WidthChanged();
+        ForEachTaskbarWnd([](CTaskBarDlg* taskbar_wnd) { taskbar_wnd->WidthChanged(); });
     }
 }
 
@@ -1586,7 +1684,7 @@ void CTrafficMonitorDlg::OnTimer(UINT_PTR nIDEvent)
                 ShowWindow(SW_HIDE);
 
             //打开任务栏窗口
-            if (theApp.m_cfg_data.m_show_task_bar_wnd && m_tBarDlg == nullptr)
+            if (theApp.m_cfg_data.m_show_task_bar_wnd && !IsTaskbarWndValid())
                 OpenTaskBarWnd();
 
             //如果窗口的位置为(0, 0)，则在初始化时MoveWindow函数无效，此时再移动一次窗口
@@ -1689,27 +1787,47 @@ void CTrafficMonitorDlg::OnTimer(UINT_PTR nIDEvent)
             //每隔10秒钟检测一次是否可以嵌入任务栏
             if (!theApp.m_win_version.IsWine() && IsTaskbarWndValid() && m_timer_cnt % 10 == 1)
             {
-                if (m_tBarDlg->GetCannotInsertToTaskBar() && m_insert_to_taskbar_cnt < MAX_INSERT_TO_TASKBAR_CNT)
+                auto get_taskbar_insert_state = [&](bool& cannot_insert_to_taskbar, int& taskbar_error_code)
+                {
+                    cannot_insert_to_taskbar = false;
+                    taskbar_error_code = 0;
+                    ForEachTaskbarWnd([&](CTaskBarDlg* taskbar_wnd)
+                    {
+                        if (taskbar_wnd->GetCannotInsertToTaskBar())
+                        {
+                            cannot_insert_to_taskbar = true;
+                            taskbar_error_code = taskbar_wnd->GetErrorCode();
+                        }
+                    });
+                };
+
+                bool cannot_insert_to_taskbar{};
+                int taskbar_error_code{};
+                get_taskbar_insert_state(cannot_insert_to_taskbar, taskbar_error_code);
+
+                if (cannot_insert_to_taskbar && m_insert_to_taskbar_cnt < MAX_INSERT_TO_TASKBAR_CNT)
                 {
                     CloseTaskBarWnd();
                     OpenTaskBarWnd();
                     m_insert_to_taskbar_cnt++;
-                    if (m_tBarDlg->GetCannotInsertToTaskBar() && m_insert_to_taskbar_cnt >= WARN_INSERT_TO_TASKBAR_CNT)
+                    get_taskbar_insert_state(cannot_insert_to_taskbar, taskbar_error_code);
+                    if (cannot_insert_to_taskbar && m_insert_to_taskbar_cnt >= WARN_INSERT_TO_TASKBAR_CNT)
                     {
                         //写入错误日志
                         CString info = CCommon::LoadText(IDS_CONNOT_INSERT_TO_TASKBAR_ERROR_LOG);
                         info.Replace(_T("<%cnt%>"), CCommon::IntToString(m_insert_to_taskbar_cnt));
-                        info.Replace(_T("<%error_code%>"), CCommon::IntToString(m_tBarDlg->GetErrorCode()));
+                        info.Replace(_T("<%error_code%>"), CCommon::IntToString(taskbar_error_code));
                         CCommon::WriteLog(info, theApp.m_log_path.c_str());
                         if (m_cannot_insert_to_task_bar_warning)      //确保提示信息只弹出一次
                         {
                             //弹出错误信息
                             m_cannot_insert_to_task_bar_warning = false;
-                            MessageBox(CCommon::LoadText(IDS_CONNOT_INSERT_TO_TASKBAR, CCommon::IntToString(m_tBarDlg->GetErrorCode())), NULL, MB_ICONWARNING);
+                            MessageBox(CCommon::LoadText(IDS_CONNOT_INSERT_TO_TASKBAR, CCommon::IntToString(taskbar_error_code)), NULL, MB_ICONWARNING);
                         }
                     }
                 }
-                if (!m_tBarDlg->GetCannotInsertToTaskBar())
+                get_taskbar_insert_state(cannot_insert_to_taskbar, taskbar_error_code);
+                if (!cannot_insert_to_taskbar)
                 {
                     m_insert_to_taskbar_cnt = 0;
                 }
@@ -1809,7 +1927,7 @@ void CTrafficMonitorDlg::OnTimer(UINT_PTR nIDEvent)
             }
             if (restart_taskbar_dlg && IsTaskbarWndValid())
             {
-                m_tBarDlg->ApplyWindowTransparentColor();
+                ForEachTaskbarWnd([](CTaskBarDlg* taskbar_wnd) { taskbar_wnd->ApplyWindowTransparentColor(); });
                 //CloseTaskBarWnd();
                 //OpenTaskBarWnd();
 
@@ -1875,24 +1993,44 @@ void CTrafficMonitorDlg::OnTimer(UINT_PTR nIDEvent)
             && IsTaskbarWndValid() && theApp.m_taskbar_data.transparent_color != 0
             && !m_is_foreground_fullscreen && theApp.m_taskbar_data.disable_d2d)
         {
-            CRect rect;
-            ::GetWindowRect(m_tBarDlg->GetSafeHwnd(), rect);
-            int pointx{ rect.left - 1 };
-            if (theApp.m_taskbar_data.tbar_wnd_on_left && m_tBarDlg->IsTasksbarOnTopOrBottom())
-                pointx = rect.right + 1;
-            int pointy = rect.bottom;
-            if (pointx < 0) pointx = 0;
-            if (pointx >= m_screen_size.cx) pointx = m_screen_size.cx - 1;
-            if (pointy < 0) pointy = 0;
-            if (pointy >= m_screen_size.cy) pointy = m_screen_size.cy - 1;
-            COLORREF color = ::GetPixel(m_desktop_dc, pointx, pointy);        //取任务栏窗口左侧1像素处的颜色作为背景色
-            if (!CCommon::IsColorSimilar(color, theApp.m_taskbar_data.back_color) && (/*CWindowsSettingHelper::IsWindows10LightTheme() ||*/ color != 0))
+            auto try_update_taskbar_background_color = [&](CTaskBarDlg* taskbar_wnd) -> bool
             {
-                bool is_taskbar_transparent{ theApp.m_taskbar_data.IsTaskbarTransparent()};
-                theApp.m_taskbar_data.back_color = color;
-                theApp.m_taskbar_data.SetTaskabrTransparent(is_taskbar_transparent);
-                if (is_taskbar_transparent)
-                    m_tBarDlg->ApplyWindowTransparentColor();
+                if (!IsTaskbarWndValid(taskbar_wnd))
+                    return false;
+
+                CRect rect;
+                ::GetWindowRect(taskbar_wnd->GetSafeHwnd(), rect);
+                int pointx{ rect.left - 1 };
+                if (theApp.m_taskbar_data.tbar_wnd_on_left && taskbar_wnd->IsTasksbarOnTopOrBottom())
+                    pointx = rect.right + 1;
+                int pointy = rect.bottom;
+                if (pointx < 0) pointx = 0;
+                if (pointx >= m_screen_size.cx) pointx = m_screen_size.cx - 1;
+                if (pointy < 0) pointy = 0;
+                if (pointy >= m_screen_size.cy) pointy = m_screen_size.cy - 1;
+
+                COLORREF color = ::GetPixel(m_desktop_dc, pointx, pointy);        //取任务栏窗口左侧1像素处的颜色作为背景色
+                if (!CCommon::IsColorSimilar(color, theApp.m_taskbar_data.back_color) && (/*CWindowsSettingHelper::IsWindows10LightTheme() ||*/ color != 0))
+                {
+                    bool is_taskbar_transparent{ theApp.m_taskbar_data.IsTaskbarTransparent() };
+                    theApp.m_taskbar_data.back_color = color;
+                    theApp.m_taskbar_data.SetTaskabrTransparent(is_taskbar_transparent);
+                    if (is_taskbar_transparent)
+                    {
+                        ForEachTaskbarWnd([](CTaskBarDlg* taskbar_wnd) {
+                            taskbar_wnd->ApplyWindowTransparentColor();
+                        });
+                    }
+                    return true;
+                }
+
+                return false;
+            };
+
+            for (auto& taskbar_wnd : m_taskbar_windows)
+            {
+                if (try_update_taskbar_background_color(taskbar_wnd.get()))
+                    break;
             }
         }
 
@@ -1928,7 +2066,16 @@ void CTrafficMonitorDlg::OnTimer(UINT_PTR nIDEvent)
     if (nIDEvent == TASKBAR_TIMER)
     {
         ++m_taskbar_timer_cnt;
-        if (m_taskbar_timer_cnt % 5 == 0 && theApp.m_cfg_data.m_show_task_bar_wnd && theApp.m_taskbar_data.show_taskbar_wnd_in_secondary_display)
+        bool has_secondary_taskbar_target{};
+        for (const auto& display_index : theApp.m_taskbar_data.taskbar_display_indices)
+        {
+            if (display_index > 0)
+            {
+                has_secondary_taskbar_target = true;
+                break;
+            }
+        }
+        if (m_taskbar_timer_cnt % 5 == 0 && theApp.m_cfg_data.m_show_task_bar_wnd && has_secondary_taskbar_target)
         {
             static int last_taskbar_num = 0;
             int taskbar_num = CTaskbarHelper::GetSecondaryTaskbarNum();
@@ -1947,24 +2094,32 @@ void CTrafficMonitorDlg::OnTimer(UINT_PTR nIDEvent)
 
         if (IsTaskbarWndValid())
         {
-            //启动时就隐藏主窗体的情况下，无法收到dpichange消息，故需要手动检查
-            //每次100ms*10执行一次屏幕DPI检查，并且尽可能少的检查操作系统版本
-            if (m_taskbar_timer_cnt % 10 == 0 && theApp.m_win_version.IsWindows8Point1OrLater())
+            auto update_taskbar_wnd = [&](CTaskBarDlg* taskbar_wnd)
             {
-                CTaskBarDlg::CheckWindowMonitorDPIAndHandle(*m_tBarDlg, [p_TaskBarDlg = m_tBarDlg](UINT new_dpi_x, UINT new_dpi_y)
-                                                            {
-                                                                // auto s_dpi = std::to_string(new_dpi_x);
-                                                                // s_dpi += '\n';
-                                                                // TRACE(s_dpi.c_str());
-                                                                //考虑到任务栏窗口可能和主窗口不在同一个屏幕上，dpi可能不同
-                                                                //设置DPI并刷新窗口
-                                                                p_TaskBarDlg->SetDPI(new_dpi_x);
-                                                                p_TaskBarDlg->SetTextFont();
-                                                                p_TaskBarDlg->CalculateWindowSize(); });
-            }
+                if (!IsTaskbarWndValid(taskbar_wnd))
+                    return;
 
-            m_tBarDlg->AdjustWindowPos();
-            m_tBarDlg->Invalidate(FALSE);
+                //启动时就隐藏主窗体的情况下，无法收到dpichange消息，故需要手动检查
+                //每次100ms*10执行一次屏幕DPI检查，并且尽可能少的检查操作系统版本
+                if (m_taskbar_timer_cnt % 10 == 0 && theApp.m_win_version.IsWindows8Point1OrLater())
+                {
+                    UINT dpi_x{}, dpi_y{};
+                    if (theApp.DPIFromRect(taskbar_wnd->GetRectForDpiCheck(), &dpi_x, &dpi_y)
+                        && dpi_x != taskbar_wnd->GetDPI())
+                    {
+                        //考虑到任务栏窗口可能和主窗口不在同一个屏幕上，dpi可能不同
+                        //设置DPI并刷新窗口
+                        taskbar_wnd->SetDPI(dpi_x);
+                        taskbar_wnd->SetTextFont();
+                        taskbar_wnd->CalculateWindowSize();
+                    }
+                }
+
+                taskbar_wnd->AdjustWindowPos();
+                taskbar_wnd->Invalidate(FALSE);
+            };
+
+            ForEachTaskbarWnd(update_taskbar_wnd);
         }
     }
 
@@ -2077,8 +2232,9 @@ void CTrafficMonitorDlg::OnNetworkInfo()
     aDlg.m_start_time = m_start_time;
     aDlg.DoModal();
     //SetAlwaysOnTop(); //由于在“连接详情”对话框内设置了取消窗口置顶，所有在对话框关闭后，重新设置窗口置顶
-    if (m_tBarDlg != nullptr)
-        m_tBarDlg->m_tool_tips.SetWindowPos(&wndTopMost, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE);  //重新设置任务栏窗口的提示信息置顶
+    ForEachTaskbarWnd([](CTaskBarDlg* taskbar_wnd) {
+        taskbar_wnd->m_tool_tips.SetWindowPos(&wndTopMost, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE);  //重新设置任务栏窗口的提示信息置顶
+    });
 }
 
 
@@ -2137,8 +2293,9 @@ void CTrafficMonitorDlg::OnClose()
     SaveHistoryTraffic();
     BackupHistoryTrafficFile();
 
-    if (IsTaskbarWndValid())
-        m_tBarDlg->OnCancel();
+    ForEachTaskbarWnd([](CTaskBarDlg* taskbar_wnd) {
+        taskbar_wnd->OnCancel();
+    });
 
     //确保在退出前关闭所有窗口
     for (const auto& item : CBaseDialog::AllUniqueHandels())
@@ -2360,7 +2517,11 @@ afx_msg LRESULT CTrafficMonitorDlg::OnNotifyIcon(WPARAM wParam, LPARAM lParam)
         {
             //在通知区点击右键弹出右键菜单
             if (IsTaskbarWndValid())        //如果显示了任务栏窗口，则在右击了通知区图标后将焦点设置到任务栏窗口
-                m_tBarDlg->SetForegroundWindow();
+            {
+                CTaskBarDlg* taskbar_wnd = GetTaskbarWindow();
+                if (taskbar_wnd != nullptr)
+                    taskbar_wnd->SetForegroundWindow();
+            }
             else                //否则将焦点设置到主窗口
                 SetForegroundWindow();
             CPoint point1;  //定义一个用于确定光标位置的位置
@@ -2468,7 +2629,9 @@ void CTrafficMonitorDlg::OnShowCpuMemory2()
         //切换显示CPU和内存利用率时，删除任务栏窗口，再重新显示
         //CloseTaskBarWnd();
         //OpenTaskBarWnd();
-        m_tBarDlg->WidthChanged();
+        ForEachTaskbarWnd([](CTaskBarDlg* taskbar_wnd) {
+            taskbar_wnd->WidthChanged();
+        });
     }
 }
 
@@ -2501,7 +2664,7 @@ void CTrafficMonitorDlg::OnMousePenetrate()
 void CTrafficMonitorDlg::OnShowTaskBarWnd()
 {
     // TODO: 在此添加命令处理程序代码
-    if (m_tBarDlg != nullptr)
+    if (!m_taskbar_windows.empty())
     {
         CloseTaskBarWnd();
     }
@@ -2536,7 +2699,7 @@ void CTrafficMonitorDlg::OnAppAbout()
 //当资源管理器重启时会触发此消息
 LRESULT CTrafficMonitorDlg::OnTaskBarCreated(WPARAM wParam, LPARAM lParam)
 {
-    if (m_tBarDlg != nullptr)
+    if (!m_taskbar_windows.empty())
     {
         CloseTaskBarWnd();
         if (theApp.m_general_data.show_notify_icon)
@@ -2663,7 +2826,11 @@ void CTrafficMonitorDlg::OnOptions2()
 {
     CWnd* pParent = this;
     if (IsTaskbarWndValid())
-        pParent = m_tBarDlg;
+    {
+        CTaskBarDlg* taskbar_wnd = GetTaskbarWndForMenuCommand();
+        if (taskbar_wnd != nullptr)
+            pParent = taskbar_wnd;
+    }
     _OnOptions(1, pParent);
 }
 
@@ -2714,6 +2881,12 @@ void CTrafficMonitorDlg::OnCheckUpdate()
 
 afx_msg LRESULT CTrafficMonitorDlg::OnTaskbarMenuPopedUp(WPARAM wParam, LPARAM lParam)
 {
+    CTaskBarDlg* taskbar_menu_invoker = reinterpret_cast<CTaskBarDlg*>(wParam);
+    if (IsTaskbarWndValid(taskbar_menu_invoker))
+        m_taskbar_menu_invoker = taskbar_menu_invoker;
+    else
+        m_taskbar_menu_invoker = nullptr;
+
     //设置“选择连接”子菜单项中各单选项的选择状态
     SetConnectionMenuState(theApp.m_taskbar_menu.GetSubMenu(0)->GetSubMenu(0));
     SetConnectionMenuState(theApp.m_taskbar_menu_plugin.GetSubMenu(0)->GetSubMenu(0));
@@ -2740,7 +2913,9 @@ void CTrafficMonitorDlg::OnShowNetSpeed()
         }
         //CloseTaskBarWnd();
         //OpenTaskBarWnd();
-        m_tBarDlg->WidthChanged();
+        ForEachTaskbarWnd([](CTaskBarDlg* taskbar_wnd) {
+            taskbar_wnd->WidthChanged();
+        });
     }
 }
 
@@ -2796,10 +2971,11 @@ afx_msg LRESULT CTrafficMonitorDlg::OnDpichanged(WPARAM wParam, LPARAM lParam)
         //当系统版本小于Windows 8.1时使用原来的行为
         if (pThis->IsTaskbarWndValid() && !theApp.m_win_version.IsWindows8Point1OrLater())
         {
-            //为任务栏窗口重新指定DPI
-            pThis->m_tBarDlg->SetDPI(dpi);
-            //根据新的DPI重新设置任务栏窗口字体
-            pThis->m_tBarDlg->SetTextFont();
+            pThis->ForEachTaskbarWnd([](CTaskBarDlg* taskbar_wnd) {
+                //为任务栏窗口重新指定DPI，并重新设置任务栏窗口字体
+                taskbar_wnd->SetDPI(dpi);
+                taskbar_wnd->SetTextFont();
+            });
         }
 
         pThis->LoadSkinLayout();   //根据当前选择的皮肤获取布局数据
@@ -2841,8 +3017,9 @@ afx_msg LRESULT CTrafficMonitorDlg::OnMonitorInfoUpdated(WPARAM wParam, LPARAM l
         m_tool_tips.UpdateTipText(tip_info, this);
     }
     //更新任务栏窗口鼠标提示
-    if (IsTaskbarWndValid())
-        m_tBarDlg->UpdateToolTips();
+    ForEachTaskbarWnd([](CTaskBarDlg* taskbar_wnd) {
+        taskbar_wnd->UpdateToolTips();
+    });
     return 0;
 }
 
@@ -2910,8 +3087,9 @@ void CTrafficMonitorDlg::OnDisplaySettings()
         theApp.m_taskbar_data.plugin_display_item = dlg.GetPluginDisplayItem();
         //CloseTaskBarWnd();
         //OpenTaskBarWnd();
-        if (IsTaskbarWndValid())
-            m_tBarDlg->WidthChanged();
+        ForEachTaskbarWnd([](CTaskBarDlg* taskbar_wnd) {
+            taskbar_wnd->WidthChanged();
+        });
     }
 }
 
@@ -2982,20 +3160,23 @@ void CTrafficMonitorDlg::OnPluginDetail()
 
 void CTrafficMonitorDlg::OnPluginOptionsTaksbar()
 {
+    CTaskBarDlg* taskbar_wnd = GetTaskbarWndForMenuCommand();
     //判断任务栏窗口中点击的项目是否是插件项目
-    if (IsTaskbarWndValid() && m_tBarDlg->GetClickedItem().IsPlugin())
+    if (IsTaskbarWndValid(taskbar_wnd) && taskbar_wnd->GetClickedItem().IsPlugin())
     {
         //找到对应的插件
-        ITMPlugin* plugin = theApp.m_plugins.GetPluginByItem(m_tBarDlg->GetClickedItem().PluginItem());
+        ITMPlugin* plugin = theApp.m_plugins.GetPluginByItem(taskbar_wnd->GetClickedItem().PluginItem());
         if (plugin != nullptr)
         {
             //显示插件的选项设置
-            auto rtn = plugin->ShowOptionsDialog(m_tBarDlg->GetSafeHwnd());
+            auto rtn = plugin->ShowOptionsDialog(taskbar_wnd->GetSafeHwnd());
             if (rtn == ITMPlugin::OR_OPTION_CHANGED)    //选项设置有更改，重新打开任务栏窗口
             {
                 //CloseTaskBarWnd();
                 //OpenTaskBarWnd();
-                m_tBarDlg->WidthChanged();
+                ForEachTaskbarWnd([](CTaskBarDlg* taskbar_wnd) {
+                    taskbar_wnd->WidthChanged();
+                });
             }
             if (rtn == ITMPlugin::OR_OPTION_NOT_PROVIDED)
                 MessageBox(CCommon::LoadText(IDS_PLUGIN_NO_OPTIONS_INFO), nullptr, MB_ICONINFORMATION | MB_OK);
@@ -3006,10 +3187,11 @@ void CTrafficMonitorDlg::OnPluginOptionsTaksbar()
 
 void CTrafficMonitorDlg::OnPluginDetailTaksbar()
 {
-    if (IsTaskbarWndValid() && m_tBarDlg->GetClickedItem().IsPlugin())
+    CTaskBarDlg* taskbar_wnd = GetTaskbarWndForMenuCommand();
+    if (IsTaskbarWndValid(taskbar_wnd) && taskbar_wnd->GetClickedItem().IsPlugin())
     {
         //找到对应的插件
-        ITMPlugin* plugin = theApp.m_plugins.GetPluginByItem(m_tBarDlg->GetClickedItem().PluginItem());
+        ITMPlugin* plugin = theApp.m_plugins.GetPluginByItem(taskbar_wnd->GetClickedItem().PluginItem());
         if (plugin != nullptr)
         {
             int index = theApp.m_plugins.GetPluginIndex(plugin);
diff --git a/TrafficMonitor/TrafficMonitorDlg.h b/TrafficMonitor/TrafficMonitorDlg.h
index 7a5e5b905..e7bafbf80 100644
--- a/TrafficMonitor/TrafficMonitorDlg.h
+++ b/TrafficMonitor/TrafficMonitorDlg.h
@@ -25,6 +25,9 @@
 #include "PdhHardwareQuery/GpuUsage.h"
 #include "PdhHardwareQuery/DiskUsage.h"
 #include "HistoryTrafficFile.h"
+#include <functional>
+#include <memory>
+#include <vector>
 
 // CTrafficMonitorDlg 对话框
 class CTrafficMonitorDlg : public CDialog
@@ -55,7 +58,8 @@ class CTrafficMonitorDlg : public CDialog
 protected:
     HICON m_hIcon;
     NOTIFYICONDATA m_ntIcon;    //通知区域图标
-    CTaskBarDlg* m_tBarDlg{};     //任务栏窗口的指针
+    std::vector<std::unique_ptr<CTaskBarDlg>> m_taskbar_windows;  //任务栏窗口集合
+    CTaskBarDlg* m_taskbar_menu_invoker{};    //当前弹出任务栏右键菜单的窗口
 
     vector<NetWorkConection> m_connections; //保存获取到的要显示到“选择网卡”菜单项中的所有网络连接
     MIB_IFTABLE* m_pIfTable;
@@ -163,6 +167,15 @@ class CTrafficMonitorDlg : public CDialog
 
     void CloseTaskBarWnd(); //关闭任务栏窗口
     void OpenTaskBarWnd();  //打开任务栏窗口
+    struct TaskbarWndTarget
+    {
+        CTaskBarDlg::DisplayTarget display_target{};
+        int secondary_display_index{};
+    };
+    std::vector<TaskbarWndTarget> BuildTaskbarWndTargets() const;
+    void CloseSingleTaskBarWnd(std::unique_ptr<CTaskBarDlg>& taskbar_wnd);
+    void OpenSingleTaskBarWnd(std::unique_ptr<CTaskBarDlg>& taskbar_wnd, const TaskbarWndTarget& target);
+    void ForEachTaskbarWnd(const std::function<void(CTaskBarDlg*)>& fn);
 
     void AddNotifyIcon();       //添加通知区图标
     void DeleteNotifyIcon();
@@ -187,6 +200,8 @@ class CTrafficMonitorDlg : public CDialog
 
 public:
     bool IsTaskbarWndValid() const;
+    bool IsTaskbarWndValid(const CTaskBarDlg* taskbar_wnd) const;
+    CTaskBarDlg* GetTaskbarWndForMenuCommand() const;
 protected:
 
     void TaskbarShowHideItem(DisplayItem type);
diff --git a/TrafficMonitor/Win11TaskbarDlg.cpp b/TrafficMonitor/Win11TaskbarDlg.cpp
index 3476e65a3..52e40db5a 100644
--- a/TrafficMonitor/Win11TaskbarDlg.cpp
+++ b/TrafficMonitor/Win11TaskbarDlg.cpp
@@ -4,6 +4,10 @@
 
 void CWin11TaskbarDlg::AdjustTaskbarWndPos(bool force_adjust)
 {
+    const int display_index = GetDisplayIndex();
+    const bool taskbar_wnd_snap = theApp.m_taskbar_data.IsTaskbarWndSnapForDisplay(display_index);
+    const bool avoid_overlap_with_widgets = theApp.m_taskbar_data.IsAvoidOverlapWithWidgetsForDisplay(display_index);
+    const int taskbar_left_space_win11 = theApp.m_taskbar_data.GetTaskbarLeftSpaceForDisplay(display_index);
     ::GetWindowRect(m_hNotify, m_rcNotify);
     ::GetWindowRect(m_hStart, m_rcStart);
     m_rcStart.MoveToXY(m_rcStart.left - m_rcTaskbar.left, m_rcStart.top - m_rcTaskbar.top);
@@ -40,8 +44,8 @@ void CWin11TaskbarDlg::AdjustTaskbarWndPos(bool force_adjust)
                     notify_x_pos = m_rcTaskbar.Width() - DPI(theApp.m_taskbar_data.taskbar_right_space_win11);
             }
             //如果显示了小组件，并且任务栏靠左显示，则留出小组件的位置
-            if (theApp.m_taskbar_data.avoid_overlap_with_widgets && CWindowsSettingHelper::IsTaskbarWidgetsBtnShown() && !CWindowsSettingHelper::IsTaskbarCenterAlign())
-                m_rect.MoveToX(notify_x_pos - m_rect.Width() + 2 - DPI(theApp.m_taskbar_data.taskbar_left_space_win11));
+            if (avoid_overlap_with_widgets && CWindowsSettingHelper::IsTaskbarWidgetsBtnShown() && !CWindowsSettingHelper::IsTaskbarCenterAlign())
+                m_rect.MoveToX(notify_x_pos - m_rect.Width() + 2 - DPI(taskbar_left_space_win11));
             else
                 m_rect.MoveToX(notify_x_pos - m_rect.Width() + 2);
             //}
@@ -50,7 +54,7 @@ void CWin11TaskbarDlg::AdjustTaskbarWndPos(bool force_adjust)
         else
         {
             //靠近“开始”按钮
-            if (theApp.m_taskbar_data.tbar_wnd_snap)
+            if (taskbar_wnd_snap)
             {
                 m_rect.MoveToX(m_rcStart.left - m_rect.Width() - 2);
             }
@@ -58,13 +62,13 @@ void CWin11TaskbarDlg::AdjustTaskbarWndPos(bool force_adjust)
             else
             {
                 if (CWindowsSettingHelper::IsTaskbarWidgetsBtnShown())
-                    m_rect.MoveToX(2 + DPI(theApp.m_taskbar_data.taskbar_left_space_win11));
+                    m_rect.MoveToX(2 + DPI(taskbar_left_space_win11));
                 else
                     m_rect.MoveToX(2);
             }
         }
         //水平偏移
-        m_rect.MoveToX(m_rect.left + DPI(theApp.m_taskbar_data.window_offset_left));
+        m_rect.MoveToX(m_rect.left + DPI(theApp.m_taskbar_data.GetWindowOffsetLeftForDisplay(display_index)));
         ////确保水平方向不超出屏幕边界
         //if (m_rect.left < 0)
         //    m_rect.MoveToX(0);
@@ -75,7 +79,7 @@ void CWin11TaskbarDlg::AdjustTaskbarWndPos(bool force_adjust)
         //注：这里加上(m_rcTaskbar.Height() - rcStart.Height())用于修正Windows11 build 22621版本后触屏设备任务栏窗口位置不正确的问题。
         //在这种情况下m_rcTaskbar的高度要大于m_rcBar的高度，正常情况下，它们的高度相同
         //但是当任务栏上没有任何图标时，m_rcBar的高度会变为0，因此使用rcStart代替
-        m_rect.MoveToY((m_rcStart.Height() - m_rect.Height()) / 2 + (m_rcTaskbar.Height() - m_rcStart.Height()) + DPI(theApp.m_taskbar_data.window_offset_top));
+        m_rect.MoveToY((m_rcStart.Height() - m_rect.Height()) / 2 + (m_rcTaskbar.Height() - m_rcStart.Height()) + DPI(theApp.m_taskbar_data.GetWindowOffsetTopForDisplay(display_index)));
         ////确保垂直方向不超出屏幕边界
         //if (m_rect.top < 0)
         //    m_rect.MoveToY(0);
diff --git a/TrafficMonitor/Win11TaskbarSettingDlg.cpp b/TrafficMonitor/Win11TaskbarSettingDlg.cpp
index 7cbe3f965..3f1a3c888 100644
--- a/TrafficMonitor/Win11TaskbarSettingDlg.cpp
+++ b/TrafficMonitor/Win11TaskbarSettingDlg.cpp
@@ -13,9 +13,10 @@
 
 IMPLEMENT_DYNAMIC(CWin11TaskbarSettingDlg, CBaseDialog)
 
-CWin11TaskbarSettingDlg::CWin11TaskbarSettingDlg(TaskBarSettingData& data, CWnd* pParent /*=nullptr*/)
+CWin11TaskbarSettingDlg::CWin11TaskbarSettingDlg(TaskBarSettingData& data, int display_index, CWnd* pParent /*=nullptr*/)
 	: CBaseDialog(IDD_WIN11_TASKBAR_SETTING_DLG, pParent)
     , m_data(data)
+    , m_display_index(display_index)
 {
 
 }
@@ -77,16 +78,27 @@ BOOL CWin11TaskbarSettingDlg::OnInitDialog()
     CBaseDialog::OnInitDialog();
     SetIcon(theApp.GetMenuIcon(IDI_TASKBAR_WINDOW), FALSE);
 
+    CString title;
+    GetWindowText(title);
+    CString display_name;
+    if (m_display_index <= 0)
+        display_name = CCommon::LoadText(IDS_PRIMARY_DISPLAY);
+    else
+        display_name = CCommon::LoadTextFormat(IDS_SECONDARY_DISPLAY, { m_display_index });
+    title += _T(" - ");
+    title += display_name;
+    SetWindowText(title);
+
     EnableDlgCtrl(IDC_TASKBAR_WND_SNAP_CHECK, CTaskBarDlg::IsTaskbarCloseToIconEnable(m_data.tbar_wnd_on_left));
-    CheckDlgButton(IDC_TASKBAR_WND_SNAP_CHECK, m_data.tbar_wnd_snap);
+    CheckDlgButton(IDC_TASKBAR_WND_SNAP_CHECK, m_data.IsTaskbarWndSnapForDisplay(m_display_index));
     m_window_offset_top_edit.SetRange(-20, 20);
-    m_window_offset_top_edit.SetValue(m_data.window_offset_top);
+    m_window_offset_top_edit.SetValue(m_data.GetWindowOffsetTopForDisplay(m_display_index));
     m_window_offset_left_edit.SetRange(-800, 800);
-    m_window_offset_left_edit.SetValue(m_data.window_offset_left);
-    CheckDlgButton(IDC_AVOID_OVERLAP_RIGHT_WIDGETS_CHECK, m_data.avoid_overlap_with_widgets);
+    m_window_offset_left_edit.SetValue(m_data.GetWindowOffsetLeftForDisplay(m_display_index));
+    CheckDlgButton(IDC_AVOID_OVERLAP_RIGHT_WIDGETS_CHECK, m_data.IsAvoidOverlapWithWidgetsForDisplay(m_display_index));
     //EnableDlgCtrl(IDC_AVOID_OVERLAP_RIGHT_WIDGETS_CHECK, CWindowsSettingHelper::IsTaskbarWidgetsBtnShown());
     m_widgets_width_edit.SetRange(0, 300);
-    m_widgets_width_edit.SetValue(m_data.taskbar_left_space_win11);
+    m_widgets_width_edit.SetValue(m_data.GetTaskbarLeftSpaceForDisplay(m_display_index));
     //m_widgets_width_edit.EnableWindow(CWindowsSettingHelper::IsTaskbarWidgetsBtnShown());
 
     return TRUE;  // return TRUE unless you set the focus to a control
@@ -96,20 +108,13 @@ BOOL CWin11TaskbarSettingDlg::OnInitDialog()
 
 void CWin11TaskbarSettingDlg::OnOK()
 {
-    m_data.tbar_wnd_snap = (IsDlgButtonChecked(IDC_TASKBAR_WND_SNAP_CHECK) != 0);
-
-    m_data.window_offset_top = m_window_offset_top_edit.GetValue();
-    m_data.ValidWindowOffsetTop();
-    m_data.window_offset_left = m_window_offset_left_edit.GetValue();
-    m_data.ValidWindowOffsetLeft();
+    m_data.SetTaskbarWndSnapForDisplay(m_display_index, (IsDlgButtonChecked(IDC_TASKBAR_WND_SNAP_CHECK) != 0));
 
-    m_data.avoid_overlap_with_widgets = (IsDlgButtonChecked(IDC_AVOID_OVERLAP_RIGHT_WIDGETS_CHECK) != 0);
+    m_data.SetWindowOffsetTopForDisplay(m_display_index, m_window_offset_top_edit.GetValue());
+    m_data.SetWindowOffsetLeftForDisplay(m_display_index, m_window_offset_left_edit.GetValue());
 
-    m_data.taskbar_left_space_win11 = m_widgets_width_edit.GetValue();
-    if (m_data.taskbar_left_space_win11 < 0)
-        m_data.taskbar_left_space_win11 = 0;
-    if (m_data.taskbar_left_space_win11 > 300)
-        m_data.taskbar_left_space_win11 = 300;
+    m_data.SetAvoidOverlapWithWidgetsForDisplay(m_display_index, (IsDlgButtonChecked(IDC_AVOID_OVERLAP_RIGHT_WIDGETS_CHECK) != 0));
+    m_data.SetTaskbarLeftSpaceForDisplay(m_display_index, m_widgets_width_edit.GetValue());
 
     CBaseDialog::OnOK();
 }
diff --git a/TrafficMonitor/Win11TaskbarSettingDlg.h b/TrafficMonitor/Win11TaskbarSettingDlg.h
index c43f41c55..f2799d54f 100644
--- a/TrafficMonitor/Win11TaskbarSettingDlg.h
+++ b/TrafficMonitor/Win11TaskbarSettingDlg.h
@@ -10,7 +10,7 @@ class CWin11TaskbarSettingDlg : public CBaseDialog
 	DECLARE_DYNAMIC(CWin11TaskbarSettingDlg)
 
 public:
-	CWin11TaskbarSettingDlg(TaskBarSettingData& data, CWnd* pParent = nullptr);   // 标准构造函数
+    CWin11TaskbarSettingDlg(TaskBarSettingData& data, int display_index, CWnd* pParent = nullptr);   // 标准构造函数
 	virtual ~CWin11TaskbarSettingDlg();
 
 // 对话框数据
@@ -20,6 +20,7 @@ class CWin11TaskbarSettingDlg : public CBaseDialog
 
 private:
     TaskBarSettingData& m_data;
+    int m_display_index{};
     CSpinEdit m_window_offset_top_edit;
     CSpinEdit m_window_offset_left_edit;
     CSpinEdit m_widgets_width_edit;
diff --git a/TrafficMonitor/resource.h b/TrafficMonitor/resource.h
index f6a70b924..839723c7b 100644
--- a/TrafficMonitor/resource.h
+++ b/TrafficMonitor/resource.h
@@ -346,6 +346,8 @@
 #define IDC_MBD_TEMP_TIP_EDIT           1219
 #define IDC_AUTO_RUN_METHOD_REGESTRY_RADIO 1220
 #define IDC_AUTO_RUN_METHOD_TASK_SCHEDULE_RADIO 1221
+#define IDC_LAYOUT_SETTINGS_FOR_DISPLAY_STATIC 1222
+#define IDC_DISPLAY_SETTINGS_GROUP_STATIC 1223
 #define ID_32771                        32771
 #define ID_NETWORK_INFO                 32772
 #define ID_32773                        32773
@@ -468,7 +470,7 @@
 #ifndef APSTUDIO_READONLY_SYMBOLS
 #define _APS_NEXT_RESOURCE_VALUE        349
 #define _APS_NEXT_COMMAND_VALUE         33666
-#define _APS_NEXT_CONTROL_VALUE         1221
+#define _APS_NEXT_CONTROL_VALUE         1224
 #define _APS_NEXT_SYMED_VALUE           101
 #endif
 #endif