Merge branch 'main' into feat/plugin-feature

src/slic3r/CMakeLists.txt

@@ -28,6 +28,8 @@ set(SLIC3R_GUI_SOURCES
     GUI/AMSMaterialsSetting.hpp
     GUI/AMSSetting.cpp
     GUI/AMSSetting.hpp
+    GUI/AMSDryControl.cpp
+    GUI/AMSDryControl.hpp
     GUI/AmsWidgets.cpp
     GUI/AmsWidgets.hpp
     GUI/Auxiliary.cpp

src/slic3r/GUI/3DScene.cpp

@@ -495,7 +495,29 @@ void GLVolume::render_with_outline(const GUI::Size& cnv_size)
         simple_render(shader, model_objects, colors);
         return;
     }
-
+    // 0th. render pass, render the model using stencil buffer
+    glsafe(::glEnable(GL_STENCIL_TEST));
+    glsafe(::glStencilMask(0xFF));
+    glsafe(::glStencilOp(GL_KEEP, GL_REPLACE, GL_REPLACE));
+    glsafe(::glClearStencil(0));
+    glsafe(::glClear(GL_STENCIL_BUFFER_BIT));
+    glsafe(::glStencilFunc(GL_ALWAYS, 0xFF, 0xFF));
+    if (tverts_range == std::make_pair<size_t, size_t>(0, -1))
+        model.render(shader);
+    else
+        model.render(this->tverts_range, shader);
+    glsafe(::glStencilFunc(GL_NOTEQUAL, 0xFF, 0xFF));
+    glsafe(::glStencilMask(0x00));
+    shader->set_uniform("is_outline", true);
+    shader->set_uniform("screen_size", Vec2f{cnv_size.get_width(), cnv_size.get_height()});
+    if (tverts_range == std::make_pair<size_t, size_t>(0, -1))
+        model.render(shader);
+    else
+        model.render(this->tverts_range, shader);
+    shader->set_uniform("is_outline", false);
+    glsafe(::glStencilMask(0xFF));
+    glsafe(::glDisable(GL_STENCIL_TEST));
+    // render the outline using depth buffer and discard the pixels that are not on the outline
     // 1st. render pass, render the model into a separate render target that has only depth buffer
     GLuint depth_fbo   = 0;
     GLuint depth_tex = 0;

src/slic3r/GUI/AMSDryControl.hpp

@@ -0,0 +1,253 @@
+#pragma once
+#include "GUI_ObjectLayers.hpp"
+#include "slic3r/GUI/Widgets/AMSItem.hpp"
+#include "slic3r/GUI/Widgets/Label.hpp"
+#include "slic3r/GUI/Widgets/PopupWindow.hpp"
+
+#include "slic3r/GUI/wxExtensions.hpp"
+#include "slic3r/GUI/DeviceCore/DevFilaSystem.h"
+#include "slic3r/GUI/I18N.hpp"
+
+#include <chrono>
+#include <optional>
+
+
+//Previous defintions
+class wxGrid;
+
+namespace Slic3r {
+
+namespace GUI {
+
+
+enum class DryCtrState {
+    IDLE,
+    DRY_WHEN_PRINT,
+    UNKNOWN
+};
+
+enum class DryCtrDev {
+    N3S,
+    N3F,
+    UNKNOWN
+};
+
+struct DryingPreset {
+    DryCtrState state;
+    DryCtrDev dev;
+    int dry_temp;
+    int dry_time;
+};
+
+class FilamentItemPanel : public wxPanel
+{
+public:
+    FilamentItemPanel(wxWindow* parent, const wxString& text, const std::string& icon_name = "",
+                      wxWindowID id = wxID_ANY);
+
+    void SetText(const wxString& text);
+    void SetIcon(const std::string& icon_name);
+    void msw_rescale();
+
+private:
+    void OnPaint(wxPaintEvent& event);
+    void OnSize(wxSizeEvent& event);
+
+    Label* m_text_label;
+    wxStaticBitmap* m_icon_bitmap;
+    int m_target_size;
+    std::string m_icon_name;
+    ScalableBitmap m_icon;
+};
+
+class AMSFilamentPanel : public wxPanel
+{
+    wxBoxSizer* m_filament_sizer;
+    Label* m_ams_name_label;
+    int m_border_radius;
+    wxPanel* m_filament_container{nullptr};
+    std::vector<FilamentItemPanel*> m_filament_items;
+
+public:
+    AMSFilamentPanel(wxWindow* parent, const wxString& ams_name, wxWindowID id = wxID_ANY);
+
+    void AddFilamentItem(const wxString& text, const std::string& icon_name);
+    void AddFilamentItem(FilamentItemPanel* panel);
+    void SetAmsName(const wxString& ams_name);
+    void Clear();
+    void msw_rescale();
+private:
+    void OnPaint(wxPaintEvent& event);
+};
+
+
+class AMSDryCtrWin : public DPIDialog
+{
+public:
+    AMSDryCtrWin(wxWindow *parent);
+    ~AMSDryCtrWin();
+
+    void msw_rescale();
+    void update(std::shared_ptr<DevFilaSystem> fila_system, MachineObject* obj);
+    void set_ams_id(const std::string& ams_id);
+
+protected:
+    void on_dpi_changed(const wxRect &suggested_rect) override;
+
+private:
+    wxSimplebook* m_main_simplebook{nullptr};
+    wxPanel* m_original_page{nullptr};
+
+    wxWindow* m_amswin{nullptr};
+    wxBoxSizer* m_sizer_ams_items{nullptr};
+    wxScrolledWindow* m_panel_prv_left {nullptr};
+    wxScrolledWindow* m_panel_prv_right{nullptr};
+    wxBoxSizer* m_sizer_prv_left{nullptr};
+    wxBoxSizer* m_sizer_prv_right{nullptr};
+
+    // left panel related members
+    ScalableBitmap m_humidity_image;
+    wxStaticBitmap* m_humidity_img{nullptr};
+    Label* m_image_description{nullptr};
+    wxStaticBitmap* m_image_description_icon{nullptr};
+    ScalableBitmap m_description_icon_bitmap;
+
+    Label* m_humidity_data_label = nullptr;
+    Label* m_temperature_data_label = nullptr;
+    Label* m_time_data_label = nullptr;
+    wxBoxSizer* m_time_descrition_container = nullptr;
+
+    // right panel related members
+    wxBoxSizer* m_normal_state_sizer{nullptr};
+    wxBoxSizer* m_cannot_dry_sizer{nullptr};
+    wxBoxSizer* m_dry_error_sizer{nullptr};
+    Label* m_cannot_dry_description_label = nullptr;
+
+    // right panel normal state
+    ComboBox* m_trays_combo;
+    std::vector<FilamentBaseInfo> m_tray_ids;
+    wxTextCtrl* m_temperature_input;
+    wxTextCtrl* m_time_input;
+    Label* m_normal_description;
+    Button* m_start_button{nullptr};
+    Button* m_next_button{nullptr};
+    Button* m_stop_button{nullptr};
+    Button* m_back_button{nullptr};
+    Button* m_unload_button{nullptr};
+
+    // guide page description
+    Label* m_guide_title_label{nullptr};
+    Label* m_guide_description_label{nullptr};
+
+    wxCheckBox* m_rotate_spool_toggle{nullptr};
+
+    wxPanel* m_progress_page;
+    ProgressBar* m_progress_gauge;
+    wxTimer* m_progress_timer;
+
+    std::optional<std::chrono::steady_clock::time_point> m_stop_button_restore_deadline;
+    std::optional<std::chrono::steady_clock::time_point> m_unload_button_restore_deadline;
+
+    Label* m_progress_title;
+    int m_progress_value;
+    int m_progress_message_index;
+    std::vector<wxString> m_progress_text = {
+        _L("Starting: Checking adapter connection"),
+        _L("Starting: Checking filament status"),
+        _L("Starting: Checking drying presets"),
+        _L("Starting: Checking filament location"),
+        _L("Starting: Checking air intake"),
+        _L("Starting: Checking air vent")
+    };
+
+    // Guide page
+    wxPanel* m_guide_page{nullptr};
+    AMSFilamentPanel* m_ams_filament_panel{nullptr};
+    std::map<std::string, FilamentItemPanel*> m_filament_items;
+    wxStaticBitmap* m_image_placeholder{nullptr};
+    ScalableBitmap m_guide_image;
+
+
+    bool m_is_ams_changed = false;
+    std::weak_ptr<DevFilaSystem> m_fila_system;
+    struct {
+        std::string m_ams_id;
+        DevAmsType m_model = DevAmsType::EXT_SPOOL;
+        DevAms::DryStatus m_dry_status = DevAms::DryStatus::Off;
+        DevAms::DrySubStatus m_dry_sub_status = DevAms::DrySubStatus::Off;
+        int m_humidity_percent;
+        int m_temperature;
+        int m_left_dry_time;
+        float m_recommand_dry_temp;
+    } m_ams_info;
+
+    struct {
+        std::unordered_map<std::string, std::string> m_filament_names;
+        std::unordered_map<std::string, std::string> m_filament_type;
+        std::unordered_map<std::string, int> m_dry_temp;
+        std::unordered_map<std::string, int> m_dry_time;
+    } m_dry_setting;
+
+    struct {
+        bool m_is_printing = false;
+    } m_printer_status;
+
+private:
+    void create();
+    wxBoxSizer* create_guide_page_sizer(wxPanel* parent);
+    wxBoxSizer* create_main_content_section(wxPanel* parent);
+    wxBoxSizer* create_guide_info_filament(wxPanel* parent);
+    wxBoxSizer* create_guide_info_section(wxPanel* parent);
+    wxBoxSizer* create_guide_right_section(wxPanel* parent);
+    wxBoxSizer* create_main_page_sizer(wxPanel* parent);
+    wxBoxSizer* create_left_panel(wxPanel* parent);
+    wxBoxSizer* create_humidity_status_section(wxPanel* parent);
+    wxBoxSizer* create_description_item(wxPanel* parent, const wxString& title, Label*& dataLabel);
+    wxBoxSizer* create_status_descriptions_section(wxPanel* parent);
+
+    wxBoxSizer* create_right_panel(wxPanel* parent);
+    wxBoxSizer* create_normal_state_panel(wxPanel* parent);
+    wxBoxSizer* create_cannot_dry_panel(wxPanel* parent);
+    wxBoxSizer* create_drying_error_panel(wxPanel* parent);
+    Button* create_button(wxPanel* parent, const wxString& title,
+        const wxColour& background_color, const wxColour& border_color, const wxColour& text_color);
+
+    wxBoxSizer* create_progress_page_sizer(wxPanel* parent);
+    void OnProgressTimer(wxTimerEvent& event);
+    void OnClose(wxCloseEvent& event);
+    void OnShow(wxShowEvent& event);
+
+    void OnFilamentSelectionChanged(wxCommandEvent& event);
+
+
+    wxScrolledWindow* create_preview_scrolled_window(wxWindow* parent);
+
+    bool check_values_changed(DevAms* dev_ams);
+    int update_image(DevAmsType type, DevAms::DryStatus status, DevAms::DrySubStatus sub_status, int humidity_percent);
+    void update_img_description(DevAms::DryStatus status, DevAms::DrySubStatus sub_status);
+    void update_normal_description(DevAms* dev_ams);
+    int update_state(DevAms* dev_ams);
+    int update_dryness_status(DevAms* dev_ams);
+    int update_ams_change(DevAms* dev_ams);
+    int update_filament_list(DevAms* dev_ams, MachineObject* obj);
+    void update_filament_guide_info(DevAms* dev_ams);
+    void update_normal_state(DevAms* dev_ams);
+    void update_printer_state(MachineObject* obj);
+
+    std::shared_ptr<DevFilaSystem> get_fila_system() const;
+    void start_sending_drying_command();
+    void restore_stop_button_if_deadline_passed();
+    void restore_unload_button_if_deadline_passed();
+    void update_button_size(Button* button);
+
+    bool is_dry_status_changed(DevAms* dev_ams);
+    bool is_dry_ctr_idle(DevAms* dev_ams);
+    bool is_ams_changed(DevAms* dev_ams);
+    bool is_dry_ctr_idle();
+    bool is_tray_changed(DevAms* dev_ams);
+    bool is_dry_ctr_err(DevAms* dev_ams);
+
+};
+
+} // GUI
+} // Slic3r

src/slic3r/GUI/ConfigWizard.cpp

@@ -1440,7 +1440,7 @@ PageTemperatures::PageTemperatures(ConfigWizard *parent)
     spin_bed->SetValue(default_bed != nullptr && default_bed->size() > 0 ? default_bed->get_at(0) : 0);
 
     append_text(_L("Enter the nozzle_temperature needed for extruding your filament."));
-    append_text(_L("A rule of thumb is 160 to 230 °C for PLA, and 215 to 250 °C for ABS."));
+    append_text(_L("A rule of thumb is 160 to 230℃ for PLA, and 215 to 250℃ for ABS."));
 #endif
 
     auto *sizer_extr = new wxFlexGridSizer(3, 5, 5);
@@ -1455,7 +1455,7 @@ PageTemperatures::PageTemperatures(ConfigWizard *parent)
     append_spacer(VERTICAL_SPACING);
 
     append_text(_L("Enter the bed temperature needed for getting your filament to stick to your heated bed."));
-    append_text(_L("A rule of thumb is 60 °C for PLA and 110 °C for ABS. Leave zero if you have no heated bed."));
+    append_text(_L("A rule of thumb is 60℃ for PLA and 110℃ for ABS. Leave zero if you have no heated bed."));
 
     auto *sizer_bed = new wxFlexGridSizer(3, 5, 5);
     auto *text_bed = new wxStaticText(this, wxID_ANY, _L("Bed Temperature:"));

src/slic3r/GUI/DeviceCore/DevDefs.h

@@ -41,6 +41,16 @@ enum AmsStatusMain
     AMS_STATUS_MAIN_UNKNOWN = 0xFF,
 };
 
+enum DevAmsType : int
+{
+    EXT_SPOOL = 0,      // EXT
+    AMS = 1,            // AMS1
+    AMS_LITE = 2,       // AMS-Lite
+    N3F = 3,            // N3F, AMS 2PRO
+    N3S = 4,            // N3S, AMS HT
+    AMS_LITE_MIXED = 5, // AMS-Lite for N9
+};
+
 // Device-numbered filament-change step codes. Newer firmware reports the exact change-step
 // sequence through the AMS (ams.cfs), keyed by these codes, instead of the client hardcoding
 // steps per model. Distinct from the legacy GUI-side Slic3r::GUI::FilamentStep enum.

src/slic3r/GUI/DeviceCore/DevFilaSystem.cpp

@@ -7,6 +7,7 @@
 #include "slic3r/GUI/I18N.hpp"
 
 #include "DevUtil.h"
+#include "DevUtilBackend.h"
 
 using namespace nlohmann;
 
@@ -99,6 +100,11 @@ std::string DevAmsTray::get_filament_type()
     return m_fila_type;
 }
 
+std::optional<Slic3r::DevFilamentDryingPreset> DevAmsTray::get_ams_drying_preset() const
+{
+    return DevUtilBackend::GetFilamentDryingPreset(setting_id);
+}
+
 
 DevAms::DevAms(const std::string& ams_id, int extruder_id, AmsType type)
 {
@@ -112,7 +118,7 @@ DevAms::DevAms(const std::string& ams_id, int nozzle_id, int type)
     m_ams_id = ams_id;
     m_ext_id = nozzle_id;
     m_ams_type = (AmsType)type;
-    assert(DUMMY < type && m_ams_type <= AMS_LITE_MIXED);
+    assert(EXT_SPOOL < type && m_ams_type <= AMS_LITE_MIXED);
 }
 
 DevAms::~DevAms()
@@ -193,6 +199,27 @@ DevAmsTray* DevAms::GetTray(const std::string& tray_id) const
     return nullptr;
 }
 
+bool DevAms::IsSupportRemoteDry(const MachineObject* obj) const
+{
+    if (obj && obj->is_support_remote_dry) {
+        return SupportDrying();
+    }
+
+    return false;
+}
+
+bool DevAms::AmsIsDrying()
+{
+    if (!GetDryStatus().has_value()) {
+        return false;
+    }
+
+    return GetDryStatus().value() == DevAms::DryStatus::Checking
+        || GetDryStatus().value() == DevAms::DryStatus::Drying
+        || GetDryStatus().value() == DevAms::DryStatus::Error
+        || GetDryStatus().value() == DevAms::DryStatus::CannotStopHeatOutofControl;
+}
+
 DevFilaSystem::~DevFilaSystem()
 {
     for (auto it = amsList.begin(); it != amsList.end(); it++)
@@ -515,9 +542,18 @@ void DevFilaSystemParser::ParseV1_0(const json& jj, MachineObject* obj, DevFilaS
                         ;
                     }
 
-                    if (it->contains("dry_time") && (*it)["dry_time"].is_number())
+
+                    if (it->contains("temp"))
                     {
-                        curr_ams->m_left_dry_time = (*it)["dry_time"].get<int>();
+                        std::string temp = (*it)["temp"].get<std::string>();
+                        try
+                        {
+                            curr_ams->m_current_temperature = DevUtil::string_to_float(temp);
+                        }
+                        catch (...)
+                        {
+                            curr_ams->m_current_temperature = INVALID_AMS_TEMPERATURE;
+                        }
                     }
 
                     if (it->contains("humidity"))
@@ -546,17 +582,32 @@ void DevFilaSystemParser::ParseV1_0(const json& jj, MachineObject* obj, DevFilaS
                         }
                     }
 
-
-                    if (it->contains("temp"))
+                    if (it->contains("dry_time") && (*it)["dry_time"].is_number())
                     {
-                        std::string temp = (*it)["temp"].get<std::string>();
-                        try
-                        {
-                            curr_ams->m_current_temperature = DevUtil::string_to_float(temp);
+                        curr_ams->m_left_dry_time = (*it)["dry_time"].get<int>();
+                    }
+
+                    // Drying status — only parse if printer supports remote drying
+                    if (obj->is_support_remote_dry) {
+                        if (it->contains("info")) {
+                            const std::string& info = (*it)["info"].get<std::string>();
+                            curr_ams->m_dry_status = (DevAms::DryStatus)DevUtil::get_flag_bits(info, 4, 4);
+                            curr_ams->m_dry_fan1_status = (DevAms::DryFanStatus)DevUtil::get_flag_bits(info, 18, 2);
+                            curr_ams->m_dry_fan2_status = (DevAms::DryFanStatus)DevUtil::get_flag_bits(info, 20, 2);
+                            curr_ams->m_dry_sub_status = (DevAms::DrySubStatus)DevUtil::get_flag_bits(info, 22, 2);
                         }
-                        catch (...)
-                        {
-                            curr_ams->m_current_temperature = INVALID_AMS_TEMPERATURE;
+
+                        if (it->contains("dry_setting")) {
+                            const auto& j_dry_settings = (*it)["dry_setting"];
+                            DevAms::DrySettings dry_settings;
+                            DevJsonValParser::ParseVal(j_dry_settings, "dry_filament", dry_settings.dry_filament);
+                            DevJsonValParser::ParseVal(j_dry_settings, "dry_temperature", dry_settings.dry_temp);
+                            DevJsonValParser::ParseVal(j_dry_settings, "dry_duration", dry_settings.dry_hour);
+                            curr_ams->m_dry_settings = dry_settings;
+                        }
+
+                        if (it->contains("dry_sf_reason")) {
+                            curr_ams->m_dry_cannot_reasons = DevJsonValParser::GetVal<std::vector<DevAms::CannotDryReason>>((*it), "dry_sf_reason");
                         }
                     }
 

src/slic3r/GUI/DeviceCore/DevFilaSystem.h

@@ -12,6 +12,9 @@
 #include <vector>
 #include <optional>
 #include <memory>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
 #include <wx/string.h>
 #include <wx/colour.h>
 
@@ -20,6 +23,7 @@
 namespace Slic3r
 {
 class MachineObject;
+struct DevFilamentDryingPreset;
 
 /**
  * DevAmsTray - Represents a single filament tray/slot in an AMS unit or virtual tray.
@@ -106,6 +110,8 @@ public:
 
     // static
     static wxColour decode_color(const std::string& color);
+
+    std::optional<DevFilamentDryingPreset> get_ams_drying_preset() const;
 };
 
 /**
@@ -133,14 +139,67 @@ class DevAms
 {
     friend class DevFilaSystemParser;
 public:
-    enum AmsType : int
+    using AmsType = DevAmsType;
+    static constexpr AmsType EXT_SPOOL = DevAmsType::EXT_SPOOL;
+    static constexpr AmsType AMS = DevAmsType::AMS;
+    static constexpr AmsType AMS_LITE = DevAmsType::AMS_LITE;
+    static constexpr AmsType N3F = DevAmsType::N3F;
+    static constexpr AmsType N3S = DevAmsType::N3S;
+    static constexpr AmsType AMS_LITE_MIXED = DevAmsType::AMS_LITE_MIXED;
+
+public:
+
+    enum class DryCtrlMode : int
     {
-        DUMMY = 0,
-        AMS = 1,      // AMS
-        AMS_LITE = 2, // AMS-Lite
-        N3F = 3,      // N3F
-        N3S = 4,      // N3S
-        AMS_LITE_MIXED = 5, // AMS-Lite mixed (A2L / N9). Presents as AMS_LITE to generic callers; see GetAmsType()/IsAmsLiteMixed().
+        Off = 0,
+        OnTime = 1,
+        OnHumidity = 2,
+    };
+
+    enum class DryStatus : char
+    {
+        Off = 0,
+        Checking = 1,
+        Drying = 2,
+        Cooling = 3,
+        Stopping = 4,
+        Error = 5,
+        CannotStopHeatOutofControl = 6,
+        PrdTesting = 7,
+    };
+
+    enum class DrySubStatus
+    {
+        Off = 0,
+        Heating = 1,
+        Dehumidify = 2,
+    };
+
+    enum class DryFanStatus : char
+    {
+        Off = 0,
+        On = 1,
+    };
+
+    enum class CannotDryReason : int
+    {
+        TaskOccupied = 0,
+        InsufficientPower = 1,
+        AmsBusy = 2,
+        ConsumableAtAmsOutlet = 3,
+        InitiatingAmsDrying = 4,
+        NotSupportedIn2dMode = 5,
+        DryingInProgress = 6,
+        Upgrading = 7,
+        InsufficientPowerNeedPluginPower = 8,
+        FilamentAtAmsOutletManualUnload = 10,
+    };
+
+    struct DrySettings
+    {
+        std::string dry_filament;
+        int dry_temp = -1; // -1 means invalid
+        int dry_hour = -1; // -1 means invalid, hours
     };
 
 public:
@@ -193,11 +252,20 @@ public:
     int   GetHumidityLevel() const { return m_humidity_level; }
     int   GetHumidityPercent() const { return m_humidity_percent; }
 
-    // Only N3F/N3S dry. Written explicitly (not `> AMS_LITE`) so the new AMS_LITE_MIXED (N9) is
-    // excluded; identical to the old expression for every pre-existing type.
-    bool  SupportDrying() const { return (m_ams_type == N3F) || (m_ams_type == N3S); }
+    bool  SupportDrying() const { return m_ams_type == DevAmsType::N3F || m_ams_type == DevAmsType::N3S; }
     int   GetLeftDryTime() const { return m_left_dry_time; }
 
+    // remote drying control
+    bool IsSupportRemoteDry(const MachineObject* obj) const;
+    std::optional<DryStatus> GetDryStatus() const { return m_dry_status; };
+    std::optional<DrySubStatus> GetDrySubStatus() const { return m_dry_sub_status; }
+    std::optional<DryFanStatus> GetFan1Status() const { return m_dry_fan1_status; }
+    std::optional<DryFanStatus> GetFan2Status() const { return m_dry_fan2_status; }
+    std::optional<std::vector<CannotDryReason>> GetCannotDryReason() const { return m_dry_cannot_reasons; }
+    std::optional<DrySettings> GetDrySettings() const { return m_dry_settings; };
+
+    bool AmsIsDrying();
+
 private:
     AmsType       m_ams_type = AmsType::AMS;
     std::string   m_ams_id;
@@ -218,6 +286,14 @@ private:
     int    m_humidity_level = 5; // AmsType::AMS
     int    m_humidity_percent = -1; // N3F N3S, the percentage, -1 means invalid. eg. 100 means 100%
     int    m_left_dry_time = 0;
+
+    // see is_support_remote_dry
+    std::optional<DryStatus> m_dry_status;
+    std::optional<DrySubStatus> m_dry_sub_status;
+    std::optional<DryFanStatus> m_dry_fan1_status;
+    std::optional<DryFanStatus> m_dry_fan2_status;
+    std::optional<std::vector<CannotDryReason>> m_dry_cannot_reasons;
+    std::optional<DrySettings> m_dry_settings;
 };
 
 /**
@@ -299,7 +375,11 @@ public:
 public:
     // ctrls
     int  CtrlAmsReset() const;
-     
+
+    // crtl
+    int  CtrlAmsStartDryingHour(int ams_id, std::string filament_type, int tag_temp, int tag_duration_hour, bool rotate_tray, int cooling_temp, bool close_power_conflict = false) const;
+    int  CtrlAmsStopDrying(int ams_id) const;
+
 public:
     static bool IsBBL_Filament(std::string tag_uid);
 
@@ -339,4 +419,18 @@ public:
     static void ParseAgentFilament(const json& data, MachineObject* obj, DevFilaSystem* system);
 };
 
+struct DevFilamentDryingPreset
+{
+    std::string filament_id;
+
+    std::unordered_set<DevAmsType> ams_limitations; // only use ams types in the set
+    std::unordered_map<DevAmsType, float> filament_dev_ams_drying_time_on_idle; // hour
+    std::unordered_map<DevAmsType, float> filament_dev_ams_drying_temperature_on_idle;
+    std::unordered_map<DevAmsType, float> filament_dev_ams_drying_time_on_print; // hour
+    std::unordered_map<DevAmsType, float> filament_dev_ams_drying_temperature_on_print;
+    float filament_dev_drying_cooling_temperature = 0.0f;
+    float filament_dev_drying_softening_temperature = 0.0f;
+    float filament_dev_ams_drying_heat_distortion_temperature = 0.0f;
+};
+
 }// namespace Slic3r

src/slic3r/GUI/DeviceCore/DevFilaSystemCtrl.cpp

@@ -16,4 +16,44 @@ int DevFilaSystem::CtrlAmsReset() const
     return m_owner->publish_json(jj_command);
 }
 
+int DevFilaSystem::CtrlAmsStartDryingHour(int ams_id,
+                                          std::string filament_type,
+                                          int tag_temp,
+                                          int tag_duration_hour,
+                                          bool rotate_tray,
+                                          int cooling_temp,
+                                          bool close_power_conflict) const
+{
+    json jj_command;
+    jj_command["print"]["command"] = "ams_filament_drying";
+    jj_command["print"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
+    jj_command["print"]["ams_id"] = ams_id;
+    jj_command["print"]["mode"] = static_cast<int>(DevAms::DryCtrlMode::OnTime);
+    jj_command["print"]["filament"] = filament_type;
+    jj_command["print"]["temp"] = tag_temp;
+    jj_command["print"]["duration"] = tag_duration_hour;
+    jj_command["print"]["humidity"] = 0;
+    jj_command["print"]["rotate_tray"] = rotate_tray;
+    jj_command["print"]["cooling_temp"] = cooling_temp;
+    jj_command["print"]["close_power_conflict"] = close_power_conflict;
+    return m_owner->publish_json(jj_command);
+}
+
+int DevFilaSystem::CtrlAmsStopDrying(int ams_id) const
+{
+    json jj_command;
+    jj_command["print"]["command"] = "ams_filament_drying";
+    jj_command["print"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
+    jj_command["print"]["ams_id"] = ams_id;
+    jj_command["print"]["mode"] = static_cast<int>(DevAms::DryCtrlMode::Off);
+    jj_command["print"]["filament"] = "";
+    jj_command["print"]["temp"] = 0;
+    jj_command["print"]["duration"] = 0;
+    jj_command["print"]["humidity"] = 0;
+    jj_command["print"]["rotate_tray"] = false;
+    jj_command["print"]["cooling_temp"] = 0;
+    jj_command["print"]["close_power_conflict"] = false;
+    return m_owner->publish_json(jj_command);
+}
+
 }

src/slic3r/GUI/DeviceCore/DevMapping.cpp

@@ -199,7 +199,7 @@ namespace Slic3r
                         }
                     }
                     FilamentInfo info;
-                    _parse_tray_info(atoi(tray.id.c_str()), 0, DevAms::DUMMY, tray, info);
+                    _parse_tray_info(atoi(tray.id.c_str()), 0, DevAms::EXT_SPOOL, tray, info);
                     tray_filaments.emplace(std::make_pair(info.tray_id, info));
                 }
             }

src/slic3r/GUI/DeviceCore/DevUtilBackend.cpp

@@ -1,7 +1,11 @@
 #include "DevUtilBackend.h"
 
 #include "slic3r/GUI/BackgroundSlicingProcess.hpp"
+
 #include "slic3r/GUI/Plater.hpp"
+#include "slic3r/GUI/GUI_App.hpp"
+
+#include <boost/log/trivial.hpp>
 
 namespace Slic3r
 {
@@ -15,4 +19,68 @@ std::shared_ptr<MultiNozzleUtils::NozzleGroupResultBase> DevUtilBackend::GetNozz
     return nullptr;
 }
 
+static std::unordered_map<std::string, DevAmsType> s_ams_type_map = {
+    {"0", DevAmsType::N3F},
+    {"1", DevAmsType::N3S},
+};
+
+std::optional<Slic3r::DevFilamentDryingPreset> DevUtilBackend::GetFilamentDryingPreset(const std::string& fila_id)
+{
+    if (fila_id.empty() || !GUI::wxGetApp().preset_bundle) {
+        return std::nullopt;
+    }
+
+    for (auto iter = GUI::wxGetApp().preset_bundle->filaments.begin(); iter != GUI::wxGetApp().preset_bundle->filaments.end(); ++iter) {
+        const Preset& filament_preset = *iter;
+        const auto& config = filament_preset.config;
+        if (filament_preset.filament_id == fila_id) {
+            DevFilamentDryingPreset info;
+            info.filament_id = fila_id;
+            try {
+                if (config.has("filament_dev_ams_drying_ams_limitations")) {
+                    std::vector<std::string> types = config.option<ConfigOptionStrings>("filament_dev_ams_drying_ams_limitations")->values;
+                    for (auto type : types) {
+                        if (s_ams_type_map.count(type) == 0) {
+                            continue;
+                        }
+                        info.ams_limitations.insert(s_ams_type_map[type]);
+                    }
+                }
+
+                if (config.has("filament_dev_ams_drying_temperature")) {
+                    info.filament_dev_ams_drying_temperature_on_idle[DevAmsType::N3F] = config.option<ConfigOptionFloats>("filament_dev_ams_drying_temperature")->get_at(0);
+                    info.filament_dev_ams_drying_temperature_on_idle[DevAmsType::N3S] = config.option<ConfigOptionFloats>("filament_dev_ams_drying_temperature")->get_at(1);
+                    info.filament_dev_ams_drying_temperature_on_print[DevAmsType::N3F] = config.option<ConfigOptionFloats>("filament_dev_ams_drying_temperature")->get_at(2);
+                    info.filament_dev_ams_drying_temperature_on_print[DevAmsType::N3S] = config.option<ConfigOptionFloats>("filament_dev_ams_drying_temperature")->get_at(3);
+                }
+
+                if (config.has("filament_dev_ams_drying_time")) {
+                    info.filament_dev_ams_drying_time_on_idle[DevAmsType::N3F] = config.option<ConfigOptionFloats>("filament_dev_ams_drying_time")->get_at(0);
+                    info.filament_dev_ams_drying_time_on_idle[DevAmsType::N3S] = config.option<ConfigOptionFloats>("filament_dev_ams_drying_time")->get_at(1);
+                    info.filament_dev_ams_drying_time_on_print[DevAmsType::N3F] = config.option<ConfigOptionFloats>("filament_dev_ams_drying_time")->get_at(2);
+                    info.filament_dev_ams_drying_time_on_print[DevAmsType::N3S] = config.option<ConfigOptionFloats>("filament_dev_ams_drying_time")->get_at(3);
+                }
+
+                if (config.has("filament_dev_drying_softening_temperature")) {
+                    info.filament_dev_drying_softening_temperature = config.option<ConfigOptionFloats>("filament_dev_drying_softening_temperature")->get_at(0);
+                }
+
+                if (config.has("filament_dev_ams_drying_heat_distortion_temperature")) {
+                    info.filament_dev_ams_drying_heat_distortion_temperature = config.option<ConfigOptionFloats>("filament_dev_ams_drying_heat_distortion_temperature")->get_at(0);
+                }
+
+                if (config.has("filament_dev_drying_cooling_temperature")) {
+                    info.filament_dev_drying_cooling_temperature = config.option<ConfigOptionFloats>("filament_dev_drying_cooling_temperature")->get_at(0);
+                }
+
+                return info;
+            } catch (const std::exception& e) {
+                BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << " exception: " << e.what();
+            }
+        }
+    }
+
+    return std::nullopt;
+}
+
 }; // namespace Slic3r

src/slic3r/GUI/DeviceCore/DevUtilBackend.h

@@ -1,18 +1,15 @@
 /**
  * @file DevUtilBackend.h
- * @brief Static helpers bridging the backend (slicer/preset) to the device GUI.
- *
- * Scope (H2C nozzle rack): exposes only GetNozzleGroupResult — the accessor the print-dispatch
- * nozzle-mapping V1 request and result-resolve helpers read. Related helpers (per-nozzle info
- * collection via the ExtruderNozzleInfos/NozzleDef type pair, and the drying-preset lookup) are
- * not implemented here and left to the consuming code.
+ * @brief Provides common static utility methods for backend (preset/slicing).
  */
 
 #pragma once
+#include "DevDefs.h"
+#include "DevFilaSystem.h"
 
 #include "libslic3r/MultiNozzleUtils.hpp"
-
-#include <memory>
+#include <optional>
+#include <string>
 
 namespace Slic3r
 {
@@ -23,10 +20,15 @@ class DevUtilBackend
 public:
     DevUtilBackend() = delete;
 
+public:
+
     // for rack: the slicer's per-filament -> logical-nozzle grouping for the current plate, read off
     // the post-slice GCodeProcessorResult (plater->background_process().get_current_gcode_result()).
     // Returns nullptr when there is no plater / no current result.
     static std::shared_ptr<MultiNozzleUtils::NozzleGroupResultBase> GetNozzleGroupResult(Slic3r::GUI::Plater* plater);
+
+    // for filament preset
+    static std::optional<DevFilamentDryingPreset> GetFilamentDryingPreset(const std::string& fila_id);
 };
 
 }; // namespace Slic3r

src/slic3r/GUI/DeviceManager.cpp

@@ -568,7 +568,7 @@ MachineObject::MachineObject(DeviceManager* manager, NetworkAgent* agent, std::s
         m_extder_system = new DevExtderSystem(this);
         m_extension_tool = DevExtensionTool::Create(this);
         m_nozzle_system = new DevNozzleSystem(this);
-        m_fila_system   = new DevFilaSystem(this);
+        m_fila_system = std::make_shared<DevFilaSystem>(this);
         m_fila_switch   = new DevFilaSwitch(this);
         m_hms_system    = new DevHMS(this);
         m_config = new DevConfig(this);
@@ -617,8 +617,6 @@ MachineObject::~MachineObject()
         delete m_ctrl;
         m_ctrl = nullptr;
 
-        delete m_fila_system;
-        m_fila_system = nullptr;
 
         delete m_fila_switch;
         m_fila_switch = nullptr;
@@ -3770,7 +3768,7 @@ int MachineObject::parse_json(std::string tunnel, std::string payload, bool key_
                     update_printer_preset_name();
                     update_filament_list();
                     if (jj.contains("ams")) {
-                        DevFilaSystemParser::ParseV1_0(jj, this, m_fila_system, key_field_only);
+                        DevFilaSystemParser::ParseV1_0(jj, this, m_fila_system.get(), key_field_only);
                     }
 
                     /* vitrual tray*/
@@ -5095,6 +5093,7 @@ void MachineObject::parse_new_info(json print)
     // fun2 may have infinite length, use get_flag_bits_no_border
     if (!fun2.empty()) {
         is_support_print_with_emmc = get_flag_bits_no_border(fun2, 0) == 1;
+        is_support_remote_dry = (get_flag_bits_no_border(fun2, 5) == 1);
         is_support_check_track_switch_match_slice_printer = get_flag_bits_no_border(fun2, 19) == 1;
     }
 

src/slic3r/GUI/DeviceManager.hpp

@@ -117,7 +117,7 @@ private:
     std::shared_ptr<DevExtensionTool> m_extension_tool;
     DevExtderSystem*  m_extder_system;
     DevNozzleSystem*  m_nozzle_system;
-    DevFilaSystem*    m_fila_system;
+    std::shared_ptr<DevFilaSystem> m_fila_system;
     DevFilaSwitch*    m_fila_switch;
     DevFan*           m_fan;
     DevBed *          m_bed;
@@ -342,7 +342,7 @@ public:
     std::shared_ptr<DevNozzleMappingCtrl> get_nozzle_mapping_result() const { return m_nozzle_mapping_ptr; }
     void clear_auto_nozzle_mapping();// defined in DevMappingNozzle.cpp
 
-    DevFilaSystem*   GetFilaSystem() const { return m_fila_system;}
+    std::shared_ptr<DevFilaSystem>   GetFilaSystem() const { return m_fila_system;}
     DevFilaSwitch*   GetFilaSwitch() const { return m_fila_switch;}
     bool             HasAms() const;
 
@@ -635,6 +635,7 @@ public:
 
     // fun2
     bool is_support_print_with_emmc{false};
+    bool is_support_remote_dry = false;
     bool is_support_check_track_switch_match_slice_printer{false};
 
     bool installed_upgrade_kit{false};

src/slic3r/GUI/GCodeViewer.cpp

@@ -445,7 +445,7 @@ void GCodeViewer::SequentialView::Marker::render_position_window(const libvgcode
             add_row(_u8L("Flow rate"), buff);
             sprintf(buff, "%.0f %%", vertex.fan_speed);
             add_row(_u8L("Fan speed"), buff);
-            sprintf(buff, ("%.0f " + _u8L("°C")).c_str(), vertex.temperature);
+            sprintf(buff, ("%.0f " + _u8L("\u2103" /* °C */)).c_str(), vertex.temperature);
             add_row(_u8L("Temperature"), buff);
             sprintf(buff, "%.4f", vertex.pressure_advance);
             add_row(_u8L("Pressure Advance"), buff);
@@ -3711,7 +3711,7 @@ void GCodeViewer::render_legend(float &legend_height, int canvas_width, int canv
         break;
     }
     case libvgcode::EViewType::FanSpeed:       { imgui.title(_u8L("Fan speed (%)")); break; }
-    case libvgcode::EViewType::Temperature:    { imgui.title(_u8L("Temperature (°C)")); break; }
+    case libvgcode::EViewType::Temperature:    { imgui.title(_u8L("Temperature (℃)")); break; }
 // ORCA: Add Pressure Advance visualization support
     case libvgcode::EViewType::PressureAdvance:{ imgui.title(_u8L("Pressure Advance")); break; }
     case libvgcode::EViewType::VolumetricFlowRate:

src/slic3r/GUI/GLCanvas3D.cpp

@@ -2338,11 +2338,6 @@ void GLCanvas3D::remove_curr_plate_all()
     m_dirty = true;
 }
 
-void GLCanvas3D::update_plate_thumbnails()
-{
-    _update_imgui_select_plate_toolbar();
-}
-
 void GLCanvas3D::select_all()
 {
     if (!m_gizmos.is_allow_select_all()) {
@@ -3228,7 +3223,6 @@ void GLCanvas3D::on_idle(wxIdleEvent& evt)
     // BBS
     //m_dirty |= wxGetApp().plater()->get_view_toolbar().update_items_state();
     m_dirty |= wxGetApp().plater()->get_collapse_toolbar().update_items_state();
-    _update_imgui_select_plate_toolbar();
     bool mouse3d_controller_applied = wxGetApp().plater()->get_mouse3d_controller().apply(wxGetApp().plater()->get_camera());
     m_dirty |= mouse3d_controller_applied;
     m_dirty |= wxGetApp().plater()->get_notification_manager()->update_notifications(*this);
@@ -4838,11 +4832,6 @@ void GLCanvas3D::force_set_focus() {
 void GLCanvas3D::on_set_focus(wxFocusEvent& evt)
 {
     m_tooltip_enabled = false;
-    if (m_canvas_type == ECanvasType::CanvasPreview) {
-        // update thumbnails and update plate toolbar
-        wxGetApp().plater()->update_all_plate_thumbnails();
-        _update_imgui_select_plate_toolbar();
-    }
     _refresh_if_shown_on_screen();
     m_tooltip_enabled = true;
     m_is_touchpad_navigation = wxGetApp().app_config->get_bool("camera_navigation_style");
@@ -6925,13 +6914,28 @@ void GLCanvas3D::_update_select_plate_toolbar_stats_item(bool force_selected) {
 bool GLCanvas3D::_update_imgui_select_plate_toolbar()
 {
     bool result = true;
-    if (!m_sel_plate_toolbar.is_enabled() || m_sel_plate_toolbar.is_render_finish) return false;
+    if (!m_sel_plate_toolbar.is_enabled()) {
+        return false;
+    }
+
+    const auto& p_plater = wxGetApp().plater();
+    if (!p_plater) {
+        return false;
+    }
+
+    if (!p_plater->is_plate_toolbar_image_dirty()) {
+        return false;
+    }
+
+    if (!p_plater->is_gcode_3mf()) { 
+        p_plater->update_all_plate_thumbnails(true);
+    }
 
     _update_select_plate_toolbar_stats_item();
 
     m_sel_plate_toolbar.del_all_item();
 
-    PartPlateList& plate_list = wxGetApp().plater()->get_partplate_list();
+    PartPlateList& plate_list = p_plater->get_partplate_list();
     for (int i = 0; i < plate_list.get_plate_count(); i++) {
         IMToolbarItem* item = new IMToolbarItem();
         PartPlate* plate = plate_list.get_plate(i);
@@ -6944,7 +6948,7 @@ bool GLCanvas3D::_update_imgui_select_plate_toolbar()
         }
         m_sel_plate_toolbar.m_items.push_back(item);
     }
-
+    p_plater->clear_plate_toolbar_image_dirty();
     m_sel_plate_toolbar.is_display_scrollbar = false;
     return result;
 }
@@ -8802,6 +8806,8 @@ void GLCanvas3D::_render_imgui_select_plate_toolbar()
         return;
     }
 
+    _update_imgui_select_plate_toolbar();
+
     IMToolbarItem* all_plates_stats_item = m_sel_plate_toolbar.m_all_plates_stats_item;
 
     PartPlateList& plate_list = wxGetApp().plater()->get_partplate_list();
@@ -9218,7 +9224,6 @@ void GLCanvas3D::_render_imgui_select_plate_toolbar()
     m_sel_plate_toolbar.is_display_scrollbar = is_win_hovered;
 
     imgui.end();
-    m_sel_plate_toolbar.is_render_finish = true;
 }
 
 //BBS: GUI refactor: GLToolbar adjust

src/slic3r/GUI/GLCanvas3D.hpp

@@ -997,7 +997,6 @@ public:
     void select_curr_plate_all();
     void select_object_from_idx(std::vector<int>& object_idxs);
     void remove_curr_plate_all();
-    void update_plate_thumbnails();
 
     void select_all();
     void deselect_all();

src/slic3r/GUI/IMToolbar.cpp

@@ -61,8 +61,6 @@ void IMToolbar::del_stats_item()
 void IMToolbar::set_enabled(bool enable)
 {
     m_enabled = enable;
-    if (!m_enabled)
-        is_render_finish = false;
 }
 
 bool IMReturnToolbar::init()

src/slic3r/GUI/IMToolbar.hpp

@@ -51,7 +51,6 @@ public:
     float icon_height;
     bool is_display_scrollbar;
     bool show_stats_item{ false };
-    bool is_render_finish{false};
     IMToolbar() {
         icon_width = DEFAULT_TOOLBAR_BUTTON_WIDTH;
         icon_height = DEFAULT_TOOLBAR_BUTTON_HEIGHT;

src/slic3r/GUI/ImGuiWrapper.cpp

@@ -3158,6 +3158,9 @@ void ImGuiWrapper::render_draw_data(ImDrawData *draw_data)
     shader->set_uniform("Texture", 0);
     shader->set_uniform("ProjMtx", ortho_projection);
 
+    const uint8_t stage = 0;
+    shader->set_uniform("s_texture", stage);
+
     // Will project scissor/clipping rectangles into framebuffer space
     const ImVec2 clip_off   = draw_data->DisplayPos;       // (0,0) unless using multi-viewports
     const ImVec2 clip_scale = draw_data->FramebufferScale; // (1,1) unless using retina display which are often (2,2)
@@ -3222,6 +3225,7 @@ void ImGuiWrapper::render_draw_data(ImDrawData *draw_data)
                 glsafe(::glScissor((int)clip_min.x, (int)(fb_height - clip_max.y), (int)(clip_max.x - clip_min.x), (int)(clip_max.y - clip_min.y)));
 
                 // Bind texture, Draw
+                glsafe(::glActiveTexture(GL_TEXTURE0 + stage));
                 glsafe(::glBindTexture(GL_TEXTURE_2D, (GLuint)(intptr_t)pcmd->GetTexID()));
                 glsafe(::glDrawElements(GL_TRIANGLES, (GLsizei)pcmd->ElemCount, sizeof(ImDrawIdx) == 2 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT, (void*)(intptr_t)(pcmd->IdxOffset * sizeof(ImDrawIdx))));
             }

src/slic3r/GUI/Jobs/FillBedJob.cpp

@@ -348,6 +348,8 @@ void FillBedJob::finalize(bool canceled, std::exception_ptr &eptr)
         }
         m_plater->update();
     }
+
+    m_plater->mark_plate_toolbar_image_dirty();
 }
 
 }} // namespace Slic3r::GUI

src/slic3r/GUI/OpenGLManager.cpp

@@ -266,7 +266,12 @@ bool OpenGLManager::init_gl(bool popup_error)
         else
             s_compressed_textures_supported = false;
 
-        if (GLAD_GL_ARB_framebuffer_object) {
+        if (s_gl_info.is_version_greater_or_equal_to(3, 0)) {
+            // ARB framebuffer became a mandatory part of core OpenGL 3.0
+            s_framebuffers_type = EFramebufferType::Arb;
+            BOOST_LOG_TRIVIAL(info) << "Opengl version >= 30, FrameBuffer Type ARB." << std::endl;
+        }
+        else if (GLAD_GL_ARB_framebuffer_object) {
             s_framebuffers_type = EFramebufferType::Arb;
             BOOST_LOG_TRIVIAL(info) << "Found Framebuffer Type ARB."<< std::endl;
         }

src/slic3r/GUI/PartPlate.cpp

@@ -2433,6 +2433,9 @@ void PartPlate::set_pos_and_size(Vec3d& origin, int width, int depth, int height
 	m_depth = depth;
 	m_height = height;
 
+	if (with_instance_move && m_plater)
+		m_plater->mark_plate_toolbar_image_dirty();
+
 	return;
 }
 
@@ -2780,6 +2783,8 @@ int PartPlate::add_instance(int obj_id, int instance_id, bool move_position, Bou
 	}
 
 	BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": plate %1% , m_ready_for_slice changes to %2%") % m_plate_index %m_ready_for_slice;
+	if (m_plater)
+		m_plater->mark_plate_toolbar_image_dirty();
 	return 0;
 }
 
@@ -5344,6 +5349,9 @@ int PartPlateList::notify_instance_removed(int obj_id, int instance_id)
 		unprintable_plate.update_object_index(obj_id, m_model->objects.size());
 	}
 
+	if (m_plater)
+		m_plater->mark_plate_toolbar_image_dirty();
+
 	return 0;
 }
 
@@ -6265,6 +6273,9 @@ int PartPlateList::rebuild_plates_after_arrangement(bool recycle_plates, bool ex
 	}
 #endif
 
+	if (m_plater)
+		m_plater->mark_plate_toolbar_image_dirty();
+
 	BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(":after rebuild, plates count %1%") % m_plate_list.size();
 	return ret;
 }

src/slic3r/GUI/Plater.cpp

@@ -290,6 +290,21 @@ void Plater::show_illegal_characters_warning(wxWindow* parent)
     show_error(parent, _L("Invalid name, the following characters are not allowed:") + " <>:/\\|?*\"");
 }
 
+void Plater::mark_plate_toolbar_image_dirty()
+{
+    m_b_plate_toolbar_image_dirty = true;
+}
+
+bool Plater::is_plate_toolbar_image_dirty() const
+{
+    return m_b_plate_toolbar_image_dirty;
+}
+
+void Plater::clear_plate_toolbar_image_dirty()
+{
+    m_b_plate_toolbar_image_dirty = false;
+}
+
 static std::map<BedType, std::string> bed_type_thumbnails = {
     {BedType::btPC,        "bed_cool"           },
     {BedType::btEP,        "bed_engineering"    },
@@ -6348,10 +6363,8 @@ void Plater::priv::update(unsigned int flags)
     //BBS assemble view
     this->assemble_view->reload_scene(false, flags);
 
-    if (current_panel && is_preview_shown()) {
-        q->force_update_all_plate_thumbnails();
-        //update_fff_scene_only_shells(true);
-    }
+    // todo: better to mark thumbnail dirty here
+    q->mark_plate_toolbar_image_dirty();
 
     if (force_background_processing_restart)
         this->restart_background_process(update_status);
@@ -7906,6 +7919,7 @@ std::vector<size_t> Plater::priv::load_files(const std::vector<fs::path>& input_
         }
     }
     q->schedule_background_process(true);
+    q->mark_plate_toolbar_image_dirty();
     return obj_idxs;
 }
 
@@ -8285,6 +8299,8 @@ void Plater::priv::object_list_changed()
     main_frame->update_slice_print_status(MainFrame::eEventObjectUpdate, can_slice);
 
     wxGetApp().params_panel()->notify_object_config_changed();
+
+    q->mark_plate_toolbar_image_dirty();
 }
 
 void Plater::priv::select_curr_plate_all()
@@ -9188,6 +9204,8 @@ void Plater::priv::update_fff_scene()
     view3D->reload_scene(true);
     //BBS: add assemble view related logic
     assemble_view->reload_scene(true);
+
+    q->mark_plate_toolbar_image_dirty();
 }
 
 //BBS: add print project related logic
@@ -10096,9 +10114,6 @@ void Plater::priv::set_current_panel(wxPanel* panel, bool no_slice)
             preview->get_canvas3d()->enable_select_plate_toolbar(true);
         }
     }
-    else {
-        preview->get_canvas3d()->enable_select_plate_toolbar(false);
-    }
 
     if (current_panel == panel)
     {
@@ -10957,6 +10972,7 @@ void Plater::priv::on_process_completed(SlicingProcessCompletedEvent &evt)
         BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(":finished, reload print soon");
         m_is_slicing = false;
         this->preview->reload_print(false);
+        q->mark_plate_toolbar_image_dirty();
         /* BBS if in publishing progress */
         if (m_is_publishing) {
             if (m_publish_dlg && !m_publish_dlg->was_cancelled()) {
@@ -13940,8 +13956,13 @@ void adjust_settings_for_flowrate_calib(ModelObjectPtrs& objects, bool linear, i
         _obj->config.set_key_value("seam_slope_type", new ConfigOptionEnum<SeamScarfType>(SeamScarfType::None));
         _obj->config.set_key_value("gap_fill_target", new ConfigOptionEnum<GapFillTarget>(GapFillTarget::gftNowhere));
         print_config->set_key_value("max_volumetric_extrusion_rate_slope", new ConfigOptionFloat(0));
-        // ORCA: print the top surface spiral from the center outwards, so the tiles are comparable.
-        _obj->config.set_key_value("top_surface_fill_order", new ConfigOptionEnum<SurfaceFillOrder>(SurfaceFillOrder::Outward));
+        // ORCA: request the calibration's special toolpath order (chords first, center spiral
+        // last and inside-out) so opposing directions collide into the tactile lip the test
+        // reads. The special order only applies while the fill order is Default, so reset the
+        // profile's fill order on the calibration objects; changing the setting on the object
+        // afterwards deliberately overrides the special order.
+        _obj->config.set_key_value("calib_flowrate_topinfill_special_order", new ConfigOptionBool(true));
+        _obj->config.set_key_value("top_surface_fill_order", new ConfigOptionEnum<SurfaceFillOrder>(SurfaceFillOrder::Default));
 
         // extract flowrate from name, filename format: flowrate_xxx
         std::string obj_name = _obj->name;
@@ -14678,6 +14699,7 @@ void Plater::invalid_all_plate_thumbnails()
         plate->thumbnail_data.reset();
         plate->no_light_thumbnail_data.reset();
     }
+    mark_plate_toolbar_image_dirty();
 }
 
 void Plater::force_update_all_plate_thumbnails()
@@ -14688,7 +14710,6 @@ void Plater::force_update_all_plate_thumbnails()
         invalid_all_plate_thumbnails();
         update_all_plate_thumbnails(true);
     }
-    get_preview_canvas3D()->update_plate_thumbnails();
 }
 
 // BBS: backup

src/slic3r/GUI/Plater.hpp

@@ -955,6 +955,10 @@ public:
 
     bool is_loading_project() const { return m_loading_project; }
 
+    void mark_plate_toolbar_image_dirty();
+    bool is_plate_toolbar_image_dirty() const;
+    void clear_plate_toolbar_image_dirty();
+
 private:
     struct priv;
     std::unique_ptr<priv> p;
@@ -975,6 +979,7 @@ private:
     std::string m_preview_only_filename;
     int m_valid_plates_count { 0 };
     int m_check_status = 0; // 0 not check, 1 check success, 2 check failed
+    bool m_b_plate_toolbar_image_dirty{ true };
 
     void suppress_snapshots();
     void allow_snapshots();

src/slic3r/GUI/SelectMachine.cpp

@@ -521,6 +521,14 @@ SelectMachineDialog::SelectMachineDialog(Plater *plater)
     //m_change_filament_times_sizer->Add(m_img_change_filament_times, 0, wxTOP, FromDIP(2));
     m_change_filament_times_sizer->Add(m_txt_change_filament_times, 0, wxTOP, 0);
 
+    m_warn_when_drying_sizer = new wxBoxSizer(wxHORIZONTAL);
+    m_txt_warn_when_drying = new Label(m_scroll_area, wxEmptyString);
+    m_txt_warn_when_drying->SetFont(::Label::Body_13);
+    m_txt_warn_when_drying->SetForegroundColour(wxColour("#F09A17"));
+    m_txt_warn_when_drying->SetBackgroundColour(*wxWHITE);
+    m_txt_warn_when_drying->SetLabel(_L("To ensure print quality, the drying temperature will be lowered during printing."));
+    m_warn_when_drying_sizer->Add(m_txt_warn_when_drying, 0, wxTOP, FromDIP(2));
+
     /*Advanced Options*/
     wxBoxSizer* sizer_split_options = new wxBoxSizer(wxHORIZONTAL);
     auto m_split_options_line = new wxPanel(m_scroll_area, wxID_ANY);
@@ -735,6 +743,8 @@ SelectMachineDialog::SelectMachineDialog(Plater *plater)
     m_scroll_sizer->Add(m_change_filament_times_sizer, 0,wxLEFT|wxRIGHT, FromDIP(15));
     // m_scroll_sizer->Add(m_link_edit_nozzle, 0, wxLEFT|wxRIGHT, FromDIP(15));
     m_scroll_sizer->Add(suggestion_sizer, 0, wxLEFT|wxRIGHT|wxEXPAND, FromDIP(15));
+    m_scroll_sizer->Add(0, 0, 0, wxTOP, FromDIP(10));
+    m_scroll_sizer->Add(m_warn_when_drying_sizer, 0, wxLEFT|wxRIGHT, FromDIP(15));
     m_scroll_sizer->Add(sizer_split_options, 1, wxEXPAND|wxLEFT|wxRIGHT, FromDIP(15));
     m_scroll_sizer->Add(0, 0, 0, wxTOP, FromDIP(10));
     m_scroll_sizer->Add(m_options_other, 0, wxEXPAND|wxLEFT|wxRIGHT, FromDIP(15));
@@ -1734,6 +1744,47 @@ bool SelectMachineDialog::CheckErrorSyncNozzleMappingResultV0(MachineObject* obj
     return true;
 }
 
+bool SelectMachineDialog::is_ams_drying(MachineObject* obj)
+{
+    const auto& ams_list = obj->GetFilaSystem()->GetAmsList();
+    for (auto ams = ams_list.begin(); ams != ams_list.end(); ams++) {
+        if (ams->second->AmsIsDrying()) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+bool SelectMachineDialog::is_selected_ams_drying(MachineObject* obj)
+{
+    if (!obj) return false;
+
+    // If a UI material is selected, only when that material is mapped to an AMS
+    // and that AMS is currently drying.
+    for (const auto &kv : m_materialList) {
+        Material *mat = kv.second;
+        if (!mat || !mat->item) continue;
+        if (!mat->item->m_selected) continue;
+
+        // find mapping entry for this material id
+        for (const FilamentInfo &f : m_ams_mapping_result) {
+            if (f.id != mat->id) continue;
+
+            if (f.ams_id.empty()) return false;
+
+            auto fila_system = obj->GetFilaSystem();
+            if (!fila_system) return false;
+            DevAms* dev_ams = fila_system->GetAmsById(f.ams_id);
+            return (dev_ams && dev_ams->AmsIsDrying());
+        }
+
+        return false;
+    }
+
+    return false;
+}
+
 void SelectMachineDialog::prepare(int print_plate_idx)
 {
     m_print_plate_idx = print_plate_idx;
@@ -3888,6 +3939,16 @@ void SelectMachineDialog::update_show_status(MachineObject* obj_)
         m_check_ext_change_assist->Enable(false);
     }
 
+    {
+        const bool show_warn_when_drying = is_selected_ams_drying(obj_);
+        const bool is_currently_shown = (m_txt_warn_when_drying != nullptr) ? m_txt_warn_when_drying->IsShown() : false;
+        if (is_currently_shown != show_warn_when_drying) {
+            m_warn_when_drying_sizer->Show(show_warn_when_drying);
+            Layout();
+            Fit();
+        }
+    }
+
      /*reading done*/
     if (wxGetApp().app_config) {
         if (obj_->upgrade_force_upgrade) {
@@ -4404,6 +4465,7 @@ void SelectMachineDialog::set_default()
     m_mapping_sugs_sizer->Show(false);
     m_change_filament_times_sizer->Show(false);
     m_txt_change_filament_times->Show(false);
+    m_warn_when_drying_sizer->Show(false);
 
     // rset status bar
     m_status_bar->reset();
@@ -4513,6 +4575,10 @@ void SelectMachineDialog::reset_and_sync_ams_list()
         m_filaments_map = wxGetApp().plater()->get_partplate_list().get_curr_plate()->get_real_filament_maps(project_config);
     }
 
+    bool          selected_any      = false;
+    MaterialItem *first_enabled     = nullptr;
+    int           first_enabled_id  = -1;
+
     for (auto i = 0; i < extruders.size(); i++) {
         auto          extruder = extruders[i] - 1;
         auto          colour   = wxGetApp().preset_bundle->project_config.opt_string("filament_colour", (unsigned int) extruder);
@@ -4542,7 +4608,20 @@ void SelectMachineDialog::reset_and_sync_ams_list()
             item = new MaterialItem(m_filament_panel, colour_rgb, _L(display_materials[extruder]));
             m_sizer_ams_mapping->Add(item, 0, wxALL, FromDIP(5));
         }
+
+        if (!item) continue;
+
         item->SetToolTip(m_ams_tooltip);
+
+        if (!selected_any && extruder == m_current_filament_id && item->m_enable) {
+            item->on_selected();
+            selected_any = true;
+        }
+        if (!first_enabled && item->m_enable) {
+            first_enabled    = item;
+            first_enabled_id = extruder;
+        }
+
         item->Bind(wxEVT_LEFT_UP, [this, item, materials, extruder](wxMouseEvent &e) {});
         item->Bind(wxEVT_LEFT_DOWN, [this, item, materials, extruder](wxMouseEvent &e) {
             if (!item->m_enable) {return;}
@@ -4621,6 +4700,11 @@ void SelectMachineDialog::reset_and_sync_ams_list()
         }
     }
 
+    if (!selected_any && first_enabled) {
+        m_current_filament_id = first_enabled_id;
+        first_enabled->on_selected();
+    }
+
     if (use_double_extruder)
     {
         m_filament_left_panel->Show();
@@ -5031,6 +5115,10 @@ void SelectMachineDialog::set_default_from_sdcard()
     m_materialList.clear();
     m_filaments.clear();
 
+    bool          selected_any      = false;
+    MaterialItem *first_enabled     = nullptr;
+    int           first_enabled_id  = -1;
+
     for (auto i = 0; i < m_required_data_plate_data_list[m_print_plate_idx]->slice_filaments_info.size(); i++) {
         FilamentInfo fo = m_required_data_plate_data_list[m_print_plate_idx]->slice_filaments_info[i];
 
@@ -5053,6 +5141,17 @@ void SelectMachineDialog::set_default_from_sdcard()
             m_sizer_ams_mapping->Add(item, 0, wxALL, FromDIP(5));
         }
 
+        if (!item) continue;
+
+        if (!selected_any && fo.id == m_current_filament_id && item->m_enable) {
+            item->on_selected();
+            selected_any = true;
+        }
+        if (!first_enabled && item->m_enable) {
+            first_enabled    = item;
+            first_enabled_id = fo.id;
+        }
+
         item->Bind(wxEVT_LEFT_UP, [this, item, materials](wxMouseEvent& e) {});
         item->Bind(wxEVT_LEFT_DOWN, [this, obj_, item, materials, diameters_count, fo](wxMouseEvent& e) {
             if (!item->m_enable) {return;}
@@ -5129,6 +5228,11 @@ void SelectMachineDialog::set_default_from_sdcard()
     wxSize screenSize = wxGetDisplaySize();
     auto dialogSize = this->GetSize();
 
+    if (!selected_any && first_enabled) {
+        m_current_filament_id = first_enabled_id;
+        first_enabled->on_selected();
+    }
+
     reset_ams_material();
 
     // basic info

src/slic3r/GUI/SelectMachine.hpp

@@ -28,6 +28,7 @@
 
 #include "boost/bimap/bimap.hpp"
 #include "AmsMappingPopup.hpp"
+#include "GUI_ObjectLayers.hpp"
 #include "ReleaseNote.hpp"
 #include "GUI_Utils.hpp"
 #include "wxExtensions.hpp"
@@ -354,6 +355,7 @@ protected:
     wxBoxSizer*                         m_sizer_autorefill{ nullptr };
     wxBoxSizer*                         m_mapping_sugs_sizer{ nullptr };
     wxBoxSizer*                         m_change_filament_times_sizer{ nullptr };
+    wxBoxSizer*                         m_warn_when_drying_sizer{ nullptr };
     Button*                             m_button_ensure{ nullptr };
     wxStaticBitmap *                    m_rename_button{nullptr};
     wxStaticBitmap*                     m_staticbitmap{ nullptr };
@@ -387,6 +389,8 @@ protected:
     CheckBox*                           m_check_ext_change_assist{ nullptr };
     Label*                              m_label_ext_change_assist{ nullptr };
 
+    Label*                              m_txt_warn_when_drying{ nullptr };
+
     PrinterInfoBox*                     m_printer_box { nullptr};
     PrinterMsgPanel *                   m_text_printer_msg{nullptr};
     Label*                              m_text_printer_msg_tips{ nullptr };
@@ -542,6 +546,9 @@ public:
     bool CheckErrorDynamicSwitchNozzle(MachineObject* obj_);
     void on_flow_cali_option_changed();
 
+    bool is_ams_drying(MachineObject* obj);
+    bool is_selected_ams_drying(MachineObject* obj);
+
     PrintFromType get_print_type() {return m_print_type;};
     wxString    format_steel_name(NozzleType type);
     PrintDialogStatus  get_status() { return m_print_status; }

src/slic3r/GUI/StatusPanel.cpp

@@ -3392,6 +3392,7 @@ void StatusPanel::update_ams(MachineObject *obj)
 
     // must select a current can
     m_ams_control->UpdateAms(obj->get_printer_series_str(), obj->printer_type, ams_info, ext_info, *obj->GetExtderSystem(), obj->get_dev_id(), false);
+    m_ams_control->UpdateAmsDryControl(obj);
 
     last_tray_exist_bits  = obj->tray_exist_bits;
     last_ams_exist_bits   = obj->ams_exist_bits;

src/slic3r/GUI/Tab.cpp

@@ -7907,7 +7907,7 @@ bool Tab::validate_filament_temperature_pairs()
         if (delta <= rule.max_delta)
             continue;
 
-        const wxString deg_c   = wxString::FromUTF8("°C");
+        const wxString deg_c   = wxString::FromUTF8("℃");
         const wxString bullet  = wxString::FromUTF8("•");
         invalid_pairs += wxString::Format(_L(" - %s:\n    %s first layer %d %s, other layers %d %s\n    %s max delta %d %s, current delta %d %s\n"),
                                           rule.label, bullet, first_temp, deg_c, other_temp, deg_c, bullet, rule.max_delta, deg_c, delta, deg_c);

src/slic3r/GUI/Widgets/AMSControl.cpp

@@ -31,6 +31,7 @@ AMSControl::AMSControl(wxWindow *parent, wxWindowID id, const wxPoint &pos, cons
     , m_Humidity_tip_popup(AmsHumidityTipPopup(this))
     , m_percent_humidity_dry_popup(new uiAmsPercentHumidityDryPopup(this))
     , m_ams_introduce_popup(AmsIntroducePopup(this))
+    , m_ams_dry_ctr_win(new AMSDryCtrWin(this))
 {
     Slic3r::DeviceManager* dev = Slic3r::GUI::wxGetApp().getDeviceManager();
     if (dev) {
@@ -252,6 +253,12 @@ AMSControl::AMSControl(wxWindow *parent, wxWindowID id, const wxPoint &pos, cons
         uiAmsHumidityInfo *info    = (uiAmsHumidityInfo *) evt.GetClientData();
         if (info)
         {
+            Slic3r::DeviceManager* dev = Slic3r::GUI::wxGetApp().getDeviceManager();
+            MachineObject *obj = nullptr;
+            if (dev) {
+                obj = dev->get_selected_machine();
+            }
+
             if (info->ams_type == AMSModel::GENERIC_AMS)
             {
                 wxPoint img_pos = ClientToScreen(wxPoint(0, 0));
@@ -261,9 +268,14 @@ AMSControl::AMSControl(wxWindow *parent, wxWindowID id, const wxPoint &pos, cons
                 int humidity_value = info->humidity_display_idx;
                 if (humidity_value > 0 && humidity_value <= 5) { m_Humidity_tip_popup.set_humidity_level(humidity_value); }
                 m_Humidity_tip_popup.Popup();
-            }
-            else
-            {
+            } else if (obj && obj->is_support_remote_dry && (info->ams_type == AMSModel::N3F_AMS || info->ams_type == AMSModel::N3S_AMS)){
+                m_ams_dry_ctr_win->set_ams_id(info->ams_id);
+
+                wxPoint img_pos = ClientToScreen(wxPoint(0, 0));
+                wxPoint popup_pos(img_pos.x - m_ams_dry_ctr_win->GetSize().GetWidth() + FromDIP(150), img_pos.y - FromDIP(80));
+                m_ams_dry_ctr_win->Move(popup_pos);
+                m_ams_dry_ctr_win->ShowModal();
+            } else {
                 m_percent_humidity_dry_popup->Update(info);
 
                 wxPoint img_pos = ClientToScreen(wxPoint(0, 0));
@@ -283,7 +295,12 @@ void AMSControl::on_retry()
     post_event(wxCommandEvent(EVT_AMS_RETRY));
 }
 
-AMSControl::~AMSControl() {}
+AMSControl::~AMSControl()
+{
+    if (m_ams_dry_ctr_win) {
+        delete m_ams_dry_ctr_win;
+    }
+}
 
 std::string AMSControl::GetCurentAms() {
     return m_current_ams;
@@ -501,6 +518,10 @@ void AMSControl::msw_rescale()
         m_percent_humidity_dry_popup->msw_rescale();
     }
 
+    if (m_ams_dry_ctr_win) {
+        m_ams_dry_ctr_win->msw_rescale();
+    }
+
     m_Humidity_tip_popup.msw_rescale();
 
     Layout();
@@ -824,6 +845,27 @@ void AMSControl::show_vams_kn_value(bool show)
     //m_vams_lib->show_kn_value(show);
 }
 
+void AMSControl::UpdateAmsDryControl(MachineObject* obj)
+{
+    if (!m_ams_dry_ctr_win->IsShown()) {
+        return;
+    }
+
+    if (!obj || !obj->GetFilaSystem()) {
+        m_ams_dry_ctr_win->Close();
+        return;
+    }
+
+    std::weak_ptr<DevFilaSystem> weak_fila_system = obj->GetFilaSystem();
+
+    if (auto locaked_fila_system = weak_fila_system.lock()) {
+        m_ams_dry_ctr_win->update(locaked_fila_system, obj);
+    } else {
+        m_ams_dry_ctr_win->Close();
+        return;
+    }
+}
+
 std::vector<AMSinfo> AMSControl::GenerateSimulateData() {
     auto caninfo0_0 = Caninfo{ "0", (""), *wxRED, AMSCanType::AMS_CAN_TYPE_VIRTUAL };
     auto caninfo0_1 = Caninfo{ "1", (""), *wxGREEN, AMSCanType::AMS_CAN_TYPE_VIRTUAL };

src/slic3r/GUI/Widgets/AMSControl.hpp

@@ -16,6 +16,7 @@
 #include <tuple>
 
 #include "slic3r/GUI/DeviceCore/DevExtruderSystem.h"
+#include "slic3r/GUI/AMSDryControl.hpp"
 
 
 namespace Slic3r { namespace GUI {
@@ -127,6 +128,7 @@ protected:
 
     AmsHumidityTipPopup m_Humidity_tip_popup;
     uiAmsPercentHumidityDryPopup* m_percent_humidity_dry_popup;
+    AMSDryCtrWin* m_ams_dry_ctr_win;
 
     std::string m_last_ams_id = "";
     std::string m_last_tray_id = "";
@@ -170,6 +172,7 @@ public:
     void CreateAmsDoubleNozzle(const std::string &series_name, const std::string& printer_type);
     void CreateAmsSingleNozzle(const std::string &series_name, const std::string &printer_type);
     void ClearAms();
+    void UpdateAmsDryControl(MachineObject* obj);
     void UpdateAms(const std::string   &series_name,
                    const std::string   &printer_type,
                    std::vector<AMSinfo> ams_info,

src/slic3r/Utils/MoonrakerPrinterAgent.cpp

@@ -536,7 +536,7 @@ void MoonrakerPrinterAgent::build_ams_payload(int ams_count, int max_lane_index,
     print_json["ams"] = ams_json;
 
     // Call the parser to populate DevFilaSystem
-    DevFilaSystemParser::ParseV1_0(print_json, obj, obj->GetFilaSystem(), false);
+    DevFilaSystemParser::ParseV1_0(print_json, obj, obj->GetFilaSystem().get(), false);
     BOOST_LOG_TRIVIAL(info) << "MoonrakerPrinterAgent::build_ams_payload: Parsed " << trays.size() << " trays";
 
     // Set printer_type so update_sync_status() can match it against the preset's printer type.