juli/OrcaSlicer
1
1
Fork 0
mirror of https://github.com/OrcaSlicer/OrcaSlicer.git synced 2026-07-18 08:22:06 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
38ab986c5fe48da791eae5e969cdba8409a0623d
OrcaSlicer/src/slic3r/GUI/AmsMappingPopup.cpp
SoftFever 38ab986c5f Drop the transitional device-layer shims
2026-07-17 12:46:45 +08:00

2729 lines
98 KiB
C++
Raw Blame History

#include "AmsMappingPopup.hpp"
#include "I18N.hpp"
#include "libslic3r/Utils.hpp"
#include "libslic3r/Thread.hpp"
#include "slic3r/Utils/WxFontUtils.hpp"
#include "GUI.hpp"
#include "GUI_App.hpp"
#include "DeviceCore/DevConfigUtil.h"
#include "GUI_Preview.hpp"
#include "MainFrame.hpp"
#include "format.hpp"
#include "Widgets/ProgressDialog.hpp"
#include "Widgets/RoundedRectangle.hpp"
#include "Widgets/StaticBox.hpp"
#include <wx/progdlg.h>
#include <wx/clipbrd.h>
#include <wx/dcgraph.h>
#include <wx/graphics.h>
#include <wx/display.h>
#include <miniz.h>
#include <algorithm>
#include <optional>
#include "Plater.hpp"
#include "BitmapCache.hpp"
#include "BindDialog.hpp"
#include "FilamentBitmapUtils.hpp"
#include "DeviceCore/DevFilaSystem.h"
#include "DeviceCore/DevFilaSwitch.h"
#include "DeviceCore/DevMappingNozzle.h"
#include "DeviceCore/DevNozzleRack.h" // Orca: full type for m_rack.lock()->GetNozzleSystem()->GetOwner()
#include "DeviceTab/wgtDeviceNozzleSelect.h"
#include "DeviceTab/wgtMsgPanel.h"
namespace Slic3r { namespace GUI {
#define MATERIAL_ITEM_SIZE wxSize(FromDIP(65), FromDIP(50))
#define MATERIAL_REC_WHEEL_SIZE wxSize(FromDIP(17), FromDIP(16))
#define MAPPING_ITEM_REAL_SIZE wxSize(FromDIP(48), FromDIP(60))
wxDEFINE_EVENT(EVT_SET_FINISH_MAPPING, wxCommandEvent);
const int LEFT_OFFSET = 2;
MaterialItem::MaterialItem(wxWindow *parent, wxColour mcolour, wxString mname, std::string filament_id)
: wxPanel(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize)
{
m_arraw_bitmap_gray = ScalableBitmap(this, "drop_down2", FromDIP(8));
m_arraw_bitmap_white = ScalableBitmap(this, "topbar_dropdown", 12);
m_transparent_mitem = ScalableBitmap(this, "transparent_material_up", 20);
m_filament_wheel_transparent = ScalableBitmap(this, "filament_transparent", 25);//wxGetApp().dark_mode() ? "filament_dark_transparent"
//m_ams_wheel_mitem = ScalableBitmap(this, "ams_wheel", FromDIP(25));
m_ams_wheel_mitem = ScalableBitmap(this, "ams_wheel_narrow", 25);
m_ams_not_match = ScalableBitmap(this, "filament_not_mactch", 25);
m_rack_nozzle_bitmap = ScalableBitmap(this, "dev_rack_nozzle_print_job", 22);
m_material_coloul = mcolour;
m_material_name = mname;
m_ams_coloul = wxColour(0xEE,0xEE,0xEE);
m_filament_id = filament_id;
#ifdef __WINDOWS__
SetDoubleBuffered(true);
#endif //__WINDOWS__
messure_size();
SetBackgroundColour(*wxWHITE);
Bind(wxEVT_PAINT, &MaterialItem::paintEvent, this);
wxGetApp().UpdateDarkUI(this);
}
MaterialItem::~MaterialItem() {}
void MaterialItem::msw_rescale() {
m_arraw_bitmap_gray.msw_rescale();
m_arraw_bitmap_white.msw_rescale();
m_transparent_mitem.msw_rescale();
m_ams_wheel_mitem.msw_rescale();
}
void MaterialItem::allow_paint_dropdown(bool flag) {
if (m_dropdown_allow_painted != flag) {
m_dropdown_allow_painted = flag;
}
}
void MaterialItem::set_ams_text(const wxString& txt)
{
if (m_ams_name != txt) {
m_ams_name = txt;
messure_size();
Refresh();
}
}
void MaterialItem::set_ams_info(wxColour col, wxString txt, int ctype, std::vector<wxColour> cols, bool record_back_info)
{
auto need_refresh = false;
if (record_back_info) {
m_back_ams_cols = cols;
m_back_ams_ctype = ctype;
m_back_ams_coloul = col;
m_back_ams_name = txt;
}
if (m_ams_cols != cols) { m_ams_cols = cols; need_refresh = true; }
if (m_ams_ctype != ctype) { m_ams_ctype = ctype; need_refresh = true; }
if (m_ams_coloul != col) { m_ams_coloul = col; need_refresh = true;}
if (m_ams_name != txt) { m_ams_name = txt; need_refresh = true; }
if (need_refresh) {
messure_size();
Refresh();
}
BOOST_LOG_TRIVIAL(info) << "set_ams_info " << m_ams_name;
}
void MaterialItem::set_nozzle_info(const wxString& mapped_nozzle_str)
{
if (m_mapped_nozzle_str != mapped_nozzle_str) {
m_mapped_nozzle_str = mapped_nozzle_str;
messure_size();
Refresh();
}
}
void MaterialItem::set_material_cols(int ctype, const std::vector<wxColour>& cols) {
if (m_material_ctype != ctype || m_material_cols != cols) {
m_material_ctype = ctype;
m_material_cols = cols;
Refresh();
}
}
void MaterialItem::reset_ams_info() {
m_ams_name = "-";
m_ams_coloul = wxColour(0xCE, 0xCE, 0xCE);
m_ams_cols.clear();
m_ams_ctype = 0;
m_mapped_nozzle_str.Clear();
messure_size();
Refresh();
}
void MaterialItem::disable()
{
if (IsEnabled()) {
m_enable = false;
}
}
void MaterialItem::enable()
{
if (!IsEnabled()) {
m_enable = true;
}
}
void MaterialItem::on_selected()
{
if (!m_selected) {
m_selected = true;
Refresh();
}
}
void MaterialItem::on_warning()
{
if (!m_warning) {
m_warning = true;
Refresh();
}
}
void MaterialItem::on_normal()
{
if (m_selected || m_warning) {
m_selected = false;
m_warning = false;
Refresh();
}
}
void MaterialItem::paintEvent(wxPaintEvent &evt)
{
wxPaintDC dc(this);
render(dc);
}
void MaterialItem::render(wxDC &dc)
{
if (m_ams_name.empty()) {
m_mapping_text = "-";
} else {
m_mapping_text = m_ams_name;
}
if (m_mapping_text == "-") { m_match = false;}
else {m_match = true;}
#ifdef __WXMSW__
wxSize size = GetSize();
wxMemoryDC memdc;
wxBitmap bmp(size.x, size.y);
memdc.SelectObject(bmp);
memdc.Blit({0, 0}, size, &dc, {0, 0});
{
wxGCDC dc2(memdc);
doRender(dc2);
}
memdc.SelectObject(wxNullBitmap);
dc.DrawBitmap(bmp, 0, 0);
#else
doRender(dc);
#endif
}
void MaterialItem::match(bool mat)
{
m_match = mat;
Refresh();
}
static constexpr size_t MAPPED_NOZZLE_STR_MAX_CHARS_PER_LINE = 7;
static wxString s_wrap_mapped_nozzle_str(const wxString& text)
{
if (text.length() <= MAPPED_NOZZLE_STR_MAX_CHARS_PER_LINE) {
return text;
}
wxArrayString parts = wxSplit(text, ',');
wxString wrapped;
std::vector<wxString> buffers;
for (auto& part : parts) {
if (!part.empty()) {
buffers.push_back(part.Trim(false).Trim(true));
}
if (buffers.size() > 2) {
if (!wrapped.empty()) {
wrapped += "\n";
}
wrapped += buffers[0];
wrapped += " ";
wrapped += buffers[1];
wrapped += " ";
wrapped += buffers[2];
buffers.clear();
}
}
if (!wrapped.empty()) {
wrapped += "\n";
}
if (buffers.size() > 0) {
wrapped += buffers[0];
}
if (buffers.size() > 1) {
wrapped += " ";
wrapped += buffers[1];
}
return wrapped;
}
static int s_get_mapped_nozzle_str_line_count(const wxString& text)
{
if (text.empty()) {
return 0;
}
return std::max(1, static_cast<int>(wxSplit(s_wrap_mapped_nozzle_str(text), '\n', '\0').size()));
}
void MaterialItem::doRender(wxDC& dc)
{
wxSize size = GetSize();
auto mcolor = m_material_coloul;
auto acolor = m_ams_coloul;
change_the_opacity(acolor);
if (mcolor.Alpha() == 0)
{
dc.DrawBitmap(m_transparent_mitem.bmp(), FromDIP(1), FromDIP(1));
}
if (!IsEnabled())
{
mcolor = wxColour(0x90, 0x90, 0x90);
acolor = wxColour(0x90, 0x90, 0x90);
}
//top
dc.SetPen(*wxTRANSPARENT_PEN);
if (m_material_cols.size() > 1 && IsEnabled()) {
int top_h = FromDIP(20);
bool drawn = false;
wxGraphicsContext* gc = dc.GetGraphicsContext();
if (gc) {
double r = FromDIP(5);
auto make_path = [&](double x, double w, bool left_round, bool right_round) {
wxGraphicsPath p = gc->CreatePath();
double rl = left_round ? std::min<double>(r, std::min<double>(w, top_h)) : 0.0;
double rr = right_round ? std::min<double>(r, std::min<double>(w, top_h)) : 0.0;
p.MoveToPoint(x, top_h);
p.AddLineToPoint(x, rl);
if (rl > 0) p.AddArc(x + rl, rl, rl, M_PI, -M_PI / 2, true);
p.AddLineToPoint(x + w - rr, 0);
if (rr > 0) p.AddArc(x + w - rr, rr, rr, -M_PI / 2, 0, true);
p.AddLineToPoint(x + w, top_h);
p.CloseSubpath();
return p;
};
if (m_material_ctype == 0) {
wxGraphicsPath path = make_path(0, size.x, true, true);
wxGraphicsGradientStops stops(m_material_cols.front(), m_material_cols.back());
for (size_t i = 1; i + 1 < m_material_cols.size(); i++) {
float pos = (float)i / (m_material_cols.size() - 1);
stops.Add(m_material_cols[i], pos);
}
gc->SetBrush(gc->CreateLinearGradientBrush(0, 0, size.x, 0, stops));
gc->FillPath(path);
} else {
int cols_size = m_material_cols.size();
for (int i = 0; i < cols_size; i++) {
double x0 = (double)size.x * i / cols_size;
double w = (i == cols_size - 1) ? (size.x - x0) : ((double)size.x / cols_size);
wxGraphicsPath seg = make_path(x0, w, i == 0, i == cols_size - 1);
gc->SetBrush(gc->CreateBrush(wxBrush(m_material_cols[i])));
gc->FillPath(seg);
}
}
drawn = true;
}
if (!drawn) {
if (m_material_ctype == 0) {
int seg = m_material_cols.size() - 1;
int gw = std::round((double)size.x / seg);
for (int i = 0; i < seg; i++) {
int x0 = gw * i;
int w = (i == seg - 1) ? (size.x - x0) : gw;
fill_gradient_rect_east(dc, wxRect(x0, 0, w, top_h), m_material_cols[i], m_material_cols[i + 1]);
}
} else {
int cols_size = m_material_cols.size();
int cw = std::round((double)size.x / cols_size);
for (int i = 0; i < cols_size; i++) {
dc.SetBrush(wxBrush(m_material_cols[i]));
int x0 = cw * i;
int w = (i == cols_size - 1) ? (size.x - x0) : cw;
dc.DrawRectangle(x0, 0, w, top_h);
}
}
}
} else {
dc.SetBrush(wxBrush(mcolor));
dc.DrawRoundedRectangle(0, 0, size.x, FromDIP(20), 5);
dc.SetPen(*wxTRANSPARENT_PEN);
dc.SetBrush(wxBrush(mcolor));
dc.DrawRectangle(0, FromDIP(10), size.x, FromDIP(10));
}
// materials name
auto up = 0;
auto material_name_colour = mcolor.GetLuminance() < 0.6 ? *wxWHITE : wxColour(0x26, 0x2E, 0x30);
if (mcolor.Alpha() == 0) { material_name_colour = wxColour(0x26, 0x2E, 0x30); }
dc.SetTextForeground(material_name_colour);
dc.SetFont(::Label::Body_12);
if (dc.GetTextExtent(m_material_name).x > GetSize().x - 10)
{
dc.SetFont(::Label::Body_10);
}
auto material_txt_size = dc.GetTextExtent(m_material_name);
dc.DrawText(m_material_name, wxPoint((GetSize().x - material_txt_size.x) / 2, (FromDIP(20) - material_txt_size.y) / 2));
dc.SetPen(wxColour(0xAC, 0xAC, 0xAC));
dc.DrawLine(FromDIP(1), FromDIP(20), FromDIP(size.x), FromDIP(20));
up += FromDIP(20);
up += FromDIP(2); // spacing
//bottom rectangle in wheel bitmap, size is MATERIAL_REC_WHEEL_SIZE(22)
auto paint_recty = up + (m_ams_wheel_mitem.GetBmpSize().y - MATERIAL_REC_WHEEL_SIZE.y) / 2;
auto left = (size.x / 2 - MATERIAL_REC_WHEEL_SIZE.x) / 2 + FromDIP(3);
auto right = left + MATERIAL_REC_WHEEL_SIZE.x - FromDIP(3);
dc.SetPen(*wxTRANSPARENT_PEN);
//bottom
if (m_ams_cols.size() > 1)
{
int gwidth = std::round(MATERIAL_REC_WHEEL_SIZE.x / (m_ams_cols.size() - 1));
//gradient
if (m_ams_ctype == 0)
{
for (int i = 0; i < m_ams_cols.size() - 1; i++)
{
auto rect = wxRect(left, paint_recty, right - left, MATERIAL_REC_WHEEL_SIZE.y);
fill_gradient_rect_east(dc, rect, m_ams_cols[i], m_ams_cols[i + 1]);
left += gwidth;
}
}
else
{
int cols_size = m_ams_cols.size();
for (int i = 0; i < cols_size; i++)
{
dc.SetBrush(wxBrush(m_ams_cols[i]));
float x = left + ((float)MATERIAL_REC_WHEEL_SIZE.x) * i / cols_size;
if (i != cols_size - 1)
{
dc.DrawRoundedRectangle(x - FromDIP(LEFT_OFFSET), paint_recty, ((float)MATERIAL_REC_WHEEL_SIZE.x) / cols_size + FromDIP(3), MATERIAL_REC_WHEEL_SIZE.y, 3);
}
else
{
dc.DrawRoundedRectangle(x - FromDIP(LEFT_OFFSET), paint_recty, ((float)MATERIAL_REC_WHEEL_SIZE.x) / cols_size - FromDIP(1), MATERIAL_REC_WHEEL_SIZE.y, 3);
}
}
}
}
else
{
if (m_match)
{
dc.SetPen(*wxTRANSPARENT_PEN);
dc.SetBrush(wxBrush(wxColour(acolor)));
dc.DrawRectangle((size.x / 2 - MATERIAL_REC_WHEEL_SIZE.x) / 2 + FromDIP(3) - FromDIP(LEFT_OFFSET), paint_recty, MATERIAL_REC_WHEEL_SIZE.x - FromDIP(1),
MATERIAL_REC_WHEEL_SIZE.y);
}
}
if (m_match)
{
dc.SetPen(wxPen(wxGetApp().dark_mode() ? wxColour(107, 107, 107) : wxColour(0xAC, 0xAC, 0xAC), FromDIP(1)));
}
else
{
dc.SetPen(wxPen(wxColour(234, 31, 48), FromDIP(1)));
}
dc.SetBrush(*wxTRANSPARENT_BRUSH);
dc.DrawRoundedRectangle(FromDIP(0), FromDIP(0), size.x - FromDIP(0), size.y, 5);
if (m_selected)
{
dc.SetPen(wxPen(wxColour("#009688"), FromDIP(2))); // ORCA selected item border color (Orca accent)
dc.SetBrush(*wxTRANSPARENT_BRUSH);
dc.DrawRoundedRectangle(FromDIP(1), FromDIP(1), size.x - FromDIP(1), size.y - FromDIP(1), 5);
} else if (m_warning) {
dc.SetPen(wxPen(wxColour(0xFF, 0x6F, 0x00), FromDIP(2)));
dc.SetBrush(*wxTRANSPARENT_BRUSH);
dc.DrawRoundedRectangle(FromDIP(1), FromDIP(1), size.x - FromDIP(1), size.y - FromDIP(1), 5);
}
//#endif
auto wheel_left = (GetSize().x / 2 - m_ams_wheel_mitem.GetBmpSize().x) / 2 + FromDIP(2) - FromDIP(LEFT_OFFSET);
auto wheel_top = up;
if (!m_match)
{
wheel_left = (size.x - m_ams_not_match.GetBmpWidth()) / 2 - FromDIP(LEFT_OFFSET);
dc.DrawBitmap(m_ams_not_match.bmp(), wheel_left, wheel_top);
}
else
{
if (acolor.Alpha() == 0)
{
dc.DrawBitmap(m_filament_wheel_transparent.bmp(), wheel_left, wheel_top);
}
else
{
dc.DrawBitmap(m_ams_wheel_mitem.bmp(), wheel_left, wheel_top);
}
}
// text and arrow
dc.SetTextForeground(StateColor::darkModeColorFor(wxColour(0x26, 0x2E, 0x30)));
int text_pos_x = 0;
int text_pos_y = 0;
auto mapping_txt_size = wxSize(0, 0);
if (m_mapping_text.size() >= 4)
{
m_mapping_text.insert(m_mapping_text.size() / 2, "\n");
WxFontUtils::get_suitable_font_size(FromDIP(13), dc);
mapping_txt_size = dc.GetTextExtent(m_mapping_text);
text_pos_y = up + (m_ams_wheel_mitem.GetBmpSize().y - mapping_txt_size.y) / 2;
text_pos_x = mapping_txt_size.x / 4;
}
else
{
dc.SetFont(::Label::Head_12);
mapping_txt_size = dc.GetTextExtent(m_mapping_text);
text_pos_y = up + (m_ams_wheel_mitem.GetBmpSize().y - mapping_txt_size.y) / 2;
text_pos_x = 0;
}
int arrow_left = size.x - m_arraw_bitmap_white.GetBmpSize().x - FromDIP(4) - FromDIP(LEFT_OFFSET);
if (m_match)
{
dc.DrawText(m_mapping_text, wxPoint(GetSize().x / 2 + (GetSize().x / 2 - mapping_txt_size.x) / 2 - FromDIP(8) - FromDIP(LEFT_OFFSET) + text_pos_x, text_pos_y));
int arrow_y = text_pos_y + (mapping_txt_size.y - m_arraw_bitmap_white.GetBmpHeight()) / 2;
if ((acolor.Red() > 160 && acolor.Green() > 160 && acolor.Blue() > 160) && (acolor.Red() < 180 && acolor.Green() < 180 && acolor.Blue() < 180))
{
dc.DrawBitmap(m_arraw_bitmap_white.bmp(), arrow_left, arrow_y);
}
else
{
dc.DrawBitmap(m_arraw_bitmap_gray.bmp(), arrow_left, arrow_y);
}
}
up += m_ams_wheel_mitem.GetBmpSize().y;
if (!m_mapped_nozzle_str.IsEmpty()) {
wxPen dashed_pen(wxColour("#CECECE"), 1, wxPENSTYLE_SHORT_DASH); // Orca: WXCOLOUR_GREY400 macro not in scope here
dc.SetPen(dashed_pen);
up += FromDIP(4); // spacing
dc.DrawLine(FromDIP(1), up, FromDIP(size.x), up);
int bitmap_y = up + (size.y - up - m_rack_nozzle_bitmap.GetBmpHeight()) / 2;
int bitmap_l = wheel_left + (m_ams_wheel_mitem.GetBmpWidth() - m_rack_nozzle_bitmap.GetBmpWidth()) / 2 + FromDIP(2);
dc.DrawBitmap(m_rack_nozzle_bitmap.bmp(), bitmap_l, bitmap_y);
const wxString wrapped_nozzle_str = s_wrap_mapped_nozzle_str(m_mapped_nozzle_str);
dc.SetFont(::Label::Head_12);
// Orca: no box-fit get_suitable_font_size overload here; the wrapped slot string is short, so the
// fixed Head_12 label font (set above) renders it cleanly.
const auto& text_size = dc.GetTextExtent(wrapped_nozzle_str);
int text_x = (size.x + bitmap_l + m_rack_nozzle_bitmap.GetBmpWidth() - text_size.x) / 2;
int text_y = up + (size.y - up - text_size.y) / 2;
dc.DrawText(wrapped_nozzle_str, text_x, text_y);
}
}
void MaterialItem::reset_valid_info() {
set_ams_info(m_back_ams_coloul, m_back_ams_name, m_back_ams_ctype, m_back_ams_cols);
}
void MaterialItem::messure_size()
{
if (m_mapped_nozzle_str.empty()) {
SetSize(wxSize(FromDIP(65), FromDIP(50)));
SetMinSize(wxSize(FromDIP(65), FromDIP(50)));
SetMaxSize(wxSize(FromDIP(65), FromDIP(50)));
} else {
const int line_count = s_get_mapped_nozzle_str_line_count(m_mapped_nozzle_str);
const int item_height = FromDIP(84 + std::max(0, line_count - 1) * 10);
SetSize(wxSize(FromDIP(65), item_height));
SetMinSize(wxSize(FromDIP(65), item_height));
SetMaxSize(wxSize(FromDIP(65), item_height));
}
}
MaterialSyncItem::MaterialSyncItem(wxWindow *parent, wxColour mcolour, wxString mname, std::string filament_id) : MaterialItem(parent, mcolour, mname, filament_id)
{
}
MaterialSyncItem::~MaterialSyncItem() {}
int MaterialSyncItem::get_real_offset() {
int real_left_offset = m_dropdown_allow_painted ? LEFT_OFFSET : -2;
return real_left_offset;
}
void MaterialSyncItem::render(wxDC &dc)
{
wxString mapping_txt = wxEmptyString;
if (m_ams_name.empty()) {
mapping_txt = "-";
} else {
mapping_txt = m_ams_name;
}
if (mapping_txt == "-") {
m_match = false;
mapping_txt = _L("Unmapped");
SetToolTip(_L("Upper half area: Original\nLower half area: The filament from original project will be used when unmapped.\nAnd you can click it to modify"));
} else {
m_match = true;
if (m_dropdown_allow_painted) {
SetToolTip(_L("Upper half area: Original\nLower half area: Filament in AMS\nAnd you can click it to modify"));
} else {
SetToolTip(_L("Upper half area: Original\nLower half area: Filament in AMS\nAnd you cannot click it to modify"));
}
}
dc.SetFont(::Label::Body_12);
if (dc.GetTextExtent(m_material_name).x > GetSize().x - 10) {
dc.SetFont(::Label::Body_10);
}
auto mapping_txt_size = dc.GetTextExtent(mapping_txt);
m_text_pos_y = ((float) GetSize().y * 3 / 5 - mapping_txt_size.y) / 2 + (float) GetSize().y * 2 / 5;
#ifdef __WXMSW__
wxSize size = GetSize();
wxMemoryDC memdc;
wxBitmap bmp(size.x, size.y);
memdc.SelectObject(bmp);
memdc.Blit({0, 0}, size, &dc, {0, 0});
{
wxGCDC dc2(memdc);
doRender(dc2);
}
memdc.SelectObject(wxNullBitmap);
dc.DrawBitmap(bmp, 0, 0);
#else
doRender(dc);
#endif
auto mcolor = m_material_coloul;
auto acolor = m_ams_coloul;
change_the_opacity(acolor);
if (!IsEnabled()) {
mcolor = wxColour(0x90, 0x90, 0x90);
acolor = wxColour(0x90, 0x90, 0x90);
}
// materials name
dc.SetFont(::Label::Body_12);
auto material_name_colour = mcolor.GetLuminance() < 0.6 ? *wxWHITE : wxColour(0x26, 0x2E, 0x30);
if (mcolor.Alpha() == 0) { material_name_colour = wxColour(0x26, 0x2E, 0x30); }
dc.SetTextForeground(material_name_colour);
auto full_text = m_material_index + " " + m_material_name;
if (dc.GetTextExtent(full_text).x > GetSize().x - 10) {
dc.SetFont(::Label::Body_10);
}
auto material_txt_size = dc.GetTextExtent(full_text);
dc.DrawText(full_text, wxPoint((GetSize().x - material_txt_size.x) / 2, ((float) GetSize().y * 2 / 5 - material_txt_size.y) / 2));
int real_left_offset = get_real_offset();
if (m_match) {
dc.SetTextForeground(StateColor::darkModeColorFor(wxColour(0x26, 0x2E, 0x30)));
dc.SetFont(::Label::Head_12);
dc.DrawText(mapping_txt, wxPoint(GetSize().x / 2 + (GetSize().x / 2 - mapping_txt_size.x) / 2 - FromDIP(8) - FromDIP(real_left_offset), m_text_pos_y));
}
else {
if (mcolor.Alpha() == 0) {//Because there is no unknown background color
material_name_colour = StateColor::darkModeColorFor(wxColour(0x26, 0x2E, 0x30));
}
dc.SetTextForeground(material_name_colour);
if (mapping_txt_size.x > GetSize().x - 10) {
dc.SetFont(::Label::Body_10);
mapping_txt_size = dc.GetTextExtent(mapping_txt);
}
dc.DrawText(mapping_txt, wxPoint(GetSize().x / 2 - mapping_txt_size.x / 2 , m_text_pos_y));
}
}
void MaterialSyncItem::doRender(wxDC &dc)
{
wxSize size = GetSize();
auto mcolor = m_material_coloul;
auto acolor = m_ams_coloul;
change_the_opacity(acolor);
if (mcolor.Alpha() == 0) {
dc.DrawBitmap(m_transparent_mitem.bmp(), FromDIP(0), FromDIP(0));
}
if (!IsEnabled()) {
mcolor = wxColour(0x90, 0x90, 0x90);
acolor = wxColour(0x90, 0x90, 0x90);
}
// top
dc.SetPen(*wxTRANSPARENT_PEN);
dc.SetBrush(wxBrush(mcolor));
dc.DrawRoundedRectangle(0, 0, size.x, FromDIP(20), 5);
dc.SetPen(*wxTRANSPARENT_PEN);
dc.SetBrush(wxBrush(mcolor));
dc.DrawRectangle(0, FromDIP(10), size.x, FromDIP(10));
dc.SetPen(wxColour(0xAC, 0xAC, 0xAC));
dc.DrawLine(FromDIP(1), FromDIP(20), FromDIP(size.x), FromDIP(20));
// bottom rectangle in wheel bitmap, size is MATERIAL_REC_WHEEL_SIZE(22)
auto left = (size.x / 2 - MATERIAL_REC_WHEEL_SIZE.x) / 2 + FromDIP(3);
auto up = (size.y * 0.4 + (size.y * 0.6 - MATERIAL_REC_WHEEL_SIZE.y) / 2);
auto right = left + MATERIAL_REC_WHEEL_SIZE.x - FromDIP(3);
dc.SetPen(*wxTRANSPARENT_PEN);
int real_left_offset = get_real_offset();
// bottom
if (m_match) {
if (m_ams_cols.size() > 1) {
int gwidth = std::round(MATERIAL_REC_WHEEL_SIZE.x / (m_ams_cols.size() - 1));
// gradient
if (m_ams_ctype == 0) {
if (!m_dropdown_allow_painted) {
left += FromDIP(5);
right += FromDIP(5);
}
for (int i = 0; i < m_ams_cols.size() - 1; i++) {
auto rect = wxRect(left, up, right - left, MATERIAL_REC_WHEEL_SIZE.y);
fill_gradient_rect_east(dc, rect, m_ams_cols[i], m_ams_cols[i + 1]);
left += gwidth;
}
} else {
if (!m_dropdown_allow_painted) {
left += FromDIP(5);
}
int cols_size = m_ams_cols.size();
for (int i = 0; i < cols_size; i++) {
dc.SetBrush(wxBrush(m_ams_cols[i]));
float x = left + ((float) MATERIAL_REC_WHEEL_SIZE.x) * i / cols_size;
if (i != cols_size - 1) {
dc.DrawRoundedRectangle(x - FromDIP(real_left_offset), up, ((float) MATERIAL_REC_WHEEL_SIZE.x) / cols_size + FromDIP(3), MATERIAL_REC_WHEEL_SIZE.y, 3);
} else {
dc.DrawRoundedRectangle(x - FromDIP(real_left_offset), up, ((float) MATERIAL_REC_WHEEL_SIZE.x) / cols_size - FromDIP(1), MATERIAL_REC_WHEEL_SIZE.y, 3);
}
}
}
} else {
dc.SetPen(*wxTRANSPARENT_PEN);
dc.SetBrush(wxBrush(wxColour(acolor)));
dc.DrawRectangle((size.x / 2 - MATERIAL_REC_WHEEL_SIZE.x) / 2 + FromDIP(3) - FromDIP(real_left_offset), up, MATERIAL_REC_WHEEL_SIZE.x - FromDIP(1),
MATERIAL_REC_WHEEL_SIZE.y);
}
}
else {
dc.SetPen(*wxTRANSPARENT_PEN);
dc.SetBrush(wxBrush(mcolor));
dc.DrawRoundedRectangle(0, FromDIP(21), size.x, size.y - FromDIP(21), 5);
dc.DrawRectangle(0, FromDIP(21), size.x, FromDIP(10));
}
////border
#if __APPLE__
dc.SetPen(wxColour(0xAC, 0xAC, 0xAC));
dc.SetBrush(*wxTRANSPARENT_BRUSH);
dc.DrawRoundedRectangle(1, 1, size.x - 1, size.y - 1, 5);
if (m_selected) {
dc.SetPen(wxColour("#009688")); // ORCA selected item border color (Orca accent)
dc.SetBrush(*wxTRANSPARENT_BRUSH);
dc.DrawRoundedRectangle(1, 1, size.x - 1, size.y - 1, 5);
}
#else
dc.SetPen(wxPen(wxGetApp().dark_mode() ? wxColour(107, 107, 107) : wxColour(0xAC, 0xAC, 0xAC), FromDIP(1)));
dc.SetBrush(*wxTRANSPARENT_BRUSH);
dc.DrawRoundedRectangle(0, 0, size.x, size.y, 5);
if (m_selected) {
dc.SetPen(wxPen(wxColour("#009688"), FromDIP(2))); // ORCA selected item border color (Orca accent)
dc.SetBrush(*wxTRANSPARENT_BRUSH);
dc.DrawRoundedRectangle(FromDIP(1), FromDIP(1), size.x - FromDIP(1), size.y - FromDIP(1), 5);
}
#endif
if (m_text_pos_y > 0 && m_match && m_dropdown_allow_painted) {
// arrow (remove arrow)
if ((acolor.Red() > 160 && acolor.Green() > 160 && acolor.Blue() > 160) && (acolor.Red() < 180 && acolor.Green() < 180 && acolor.Blue() < 180)) {
dc.DrawBitmap(m_arraw_bitmap_white.bmp(), size.x - m_arraw_bitmap_white.GetBmpSize().x - FromDIP(4) - FromDIP(real_left_offset), m_text_pos_y + FromDIP(3));
} else {
dc.DrawBitmap(m_arraw_bitmap_gray.bmp(), size.x - m_arraw_bitmap_gray.GetBmpSize().x - FromDIP(4) - FromDIP(real_left_offset), m_text_pos_y + FromDIP(3));
}
}
auto wheel_left = (GetSize().x / 2 - m_ams_wheel_mitem.GetBmpSize().x) / 2 + FromDIP(2);
auto wheel_top = ((float) GetSize().y * 0.6 - m_ams_wheel_mitem.GetBmpSize().y) / 2 + (float) GetSize().y * 0.4;
if (m_match) {// different with parent
if (acolor.Alpha() == 0) {
dc.DrawBitmap(m_filament_wheel_transparent.bmp(), wheel_left - FromDIP(real_left_offset), wheel_top);
} else {
dc.DrawBitmap(m_ams_wheel_mitem.bmp(), wheel_left - FromDIP(real_left_offset), wheel_top);
}
}
//not draw m_ams_not_match
}
void MaterialSyncItem::set_material_index_str(std::string str) {
m_material_index = str;
}
AmsMapingPopup::AmsMapingPopup(wxWindow *parent, bool use_in_sync_dialog) :
PopupWindow(parent, wxBORDER_NONE | wxPU_CONTAINS_CONTROLS), m_use_in_sync_dialog(use_in_sync_dialog)
{
Bind(wxEVT_PAINT, &AmsMapingPopup::paintEvent, this);
#ifdef __APPLE__
Bind(wxEVT_LEFT_DOWN, &AmsMapingPopup::on_left_down, this);
Bind(wxEVT_MOTION, &AmsMapingPopup::on_mouse_move, this);
#endif
SetBackgroundColour(*wxWHITE);
m_sizer_main = new wxBoxSizer(wxVERTICAL);
m_sizer_main_h = new wxBoxSizer(wxHORIZONTAL);
m_sizer_ams = new wxBoxSizer(wxHORIZONTAL);
m_sizer_ams_left = new wxBoxSizer(wxVERTICAL);
m_sizer_ams_right = new wxBoxSizer(wxVERTICAL);
m_sizer_ams_left_horizonal = new wxBoxSizer(wxHORIZONTAL);
m_sizer_ams_right_horizonal = new wxBoxSizer(wxHORIZONTAL);
m_sizer_ams_basket_left = new wxBoxSizer(wxVERTICAL);
m_sizer_ams_basket_right = new wxBoxSizer(wxVERTICAL);
auto title_panel = new wxPanel(this, wxID_ANY);
title_panel->SetBackgroundColour(StateColor::darkModeColorFor("#F1F1F1"));
title_panel->SetSize(wxSize(-1, FromDIP(30)));
title_panel->SetMinSize(wxSize(-1, FromDIP(30)));
m_scrolled_window = new wxScrolledWindow(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxVSCROLL | wxHSCROLL);
m_scrolled_window->SetBackgroundColour(*wxWHITE);
m_scrolled_window->SetScrollRate(0, FromDIP(10));
wxBoxSizer *title_sizer_h= new wxBoxSizer(wxHORIZONTAL);
wxBoxSizer *title_sizer_v = new wxBoxSizer(wxVERTICAL);
m_title_text = new wxStaticText(title_panel, wxID_ANY, _L("AMS Slots"));
m_title_text->SetForegroundColour(wxColour("#262E30"));
m_title_text->SetFont(::Label::Body_16);
title_sizer_v->Add(m_title_text, 0, wxALIGN_LEFT | wxLEFT, FromDIP(15));
title_sizer_h->Add(title_sizer_v, 1, wxALIGN_CENTER, 5);
title_panel->SetSizer(title_sizer_h);
title_panel->Layout();
title_panel->Fit();
m_left_marea_panel = new wxPanel(m_scrolled_window);
m_left_marea_panel->SetName("left");
m_right_marea_panel = new wxPanel(m_scrolled_window);
m_right_marea_panel->SetName("right");
m_left_first_text_panel = new wxPanel(m_left_marea_panel);
m_right_first_text_panel = new wxPanel(m_right_marea_panel);
auto sizer_temp = new wxBoxSizer(wxHORIZONTAL);
/*left ext*/
m_left_extra_slot = new MappingItem(m_left_marea_panel);
m_left_extra_slot->m_ams_id = VIRTUAL_TRAY_DEPUTY_ID;
m_left_extra_slot->m_slot_id = 0;
m_left_extra_slot->SetSize(wxSize(FromDIP(48), FromDIP(60)));
m_left_extra_slot->SetMinSize(wxSize(FromDIP(48), FromDIP(60)));
m_left_extra_slot->SetMaxSize(wxSize(FromDIP(48), FromDIP(60)));
auto left_panel = new wxPanel(m_left_marea_panel);
left_panel->SetSize(wxSize(FromDIP(182), FromDIP(60)));
left_panel->SetMinSize(wxSize(FromDIP(182), FromDIP(60)));
left_panel->SetMaxSize(wxSize(FromDIP(182), FromDIP(60)));
sizer_temp->Add(m_left_extra_slot);
sizer_temp->Add(left_panel);
/*right ext*/
m_right_extra_slot = new MappingItem(m_right_marea_panel);
m_right_extra_slot->m_ams_id = VIRTUAL_TRAY_MAIN_ID;
m_right_extra_slot->m_slot_id = 0;
m_right_extra_slot->SetSize(wxSize(FromDIP(48), FromDIP(60)));
m_right_extra_slot->SetMinSize(wxSize(FromDIP(48), FromDIP(60)));
m_right_extra_slot->SetMaxSize(wxSize(FromDIP(48), FromDIP(60)));
std::string amp_pt = wxGetApp().preset_bundle->printers.get_edited_preset().get_printer_type(wxGetApp().preset_bundle);
m_single_tip_text = _L("Please select from the following filaments");
m_left_tip_text = wxString::Format(_L("Select filament that installed to the %s"),
_L(DevPrinterConfigUtil::get_toolhead_display_name(amp_pt, DEPUTY_EXTRUDER_ID, ToolHeadComponent::Nozzle, ToolHeadNameCase::LowerCase)));
m_right_tip_text = wxString::Format(_L("Select filament that installed to the %s"),
_L(DevPrinterConfigUtil::get_toolhead_display_name(amp_pt, MAIN_EXTRUDER_ID, ToolHeadComponent::Nozzle, ToolHeadNameCase::LowerCase)));
m_left_tips = new Label(m_left_first_text_panel);
m_left_tips->SetForegroundColour(StateColor::darkModeColorFor("0x262E30"));
m_left_tips->SetBackgroundColour(StateColor::darkModeColorFor("0xFFFFFF"));
m_left_tips->SetFont(::Label::Body_13);
m_left_tips->SetLabel(m_left_tip_text);
m_left_first_text_panel->SetSizer(m_sizer_ams_left_horizonal);
m_sizer_ams_left->Add(m_left_first_text_panel, 0, wxEXPAND | wxBOTTOM | wxTOP , FromDIP(8));
m_left_split_ams_sizer = create_split_sizer(m_left_marea_panel, _L("Left AMS"));
m_sizer_ams_left->Add(m_left_split_ams_sizer, 0, wxEXPAND, 0);
m_sizer_ams_left->Add(m_sizer_ams_basket_left, 0, wxEXPAND|wxTOP, FromDIP(8));
m_sizer_ams_left->Add(create_split_sizer(m_left_marea_panel, _L("External")), 0, wxEXPAND|wxTOP, FromDIP(8));
//m_sizer_ams_left->Add(m_left_extra_slot, 0, wxEXPAND|wxTOP, FromDIP(8));
m_sizer_ams_left->Add(sizer_temp, 0, wxEXPAND | wxTOP, FromDIP(8));
m_right_tips = new Label(m_right_first_text_panel);
m_right_tips->SetForegroundColour(StateColor::darkModeColorFor("0x262E30"));
m_right_tips->SetBackgroundColour(StateColor::darkModeColorFor("0xFFFFFF"));
m_right_tips->SetFont(::Label::Body_13);
m_right_tips->SetLabel(m_right_tip_text);
m_sizer_ams_right_horizonal->AddStretchSpacer();
m_reset_btn = new ScalableButton(m_scrolled_window, wxID_ANY, wxGetApp().dark_mode() ? "erase_dark" : "erase", wxEmptyString, wxDefaultSize, wxDefaultPosition,
wxBU_EXACTFIT | wxNO_BORDER, true, 14);
m_reset_btn->SetName(wxGetApp().dark_mode() ? "erase_dark" : "erase");
m_reset_btn->Bind(wxEVT_BUTTON, [this](wxCommandEvent &e) { reset_ams_info(); });
m_reset_btn->SetBackgroundColour(*wxWHITE);
m_reset_btn->SetToolTip(_L("Reset current filament mapping"));
m_sizer_ams_right_horizonal->AddStretchSpacer();
m_sizer_ams_right_horizonal->AddSpacer(FromDIP(5));
m_reset_btn->Hide();
m_right_first_text_panel->SetSizer(m_sizer_ams_right_horizonal);
const int same_height = 20;
m_left_first_text_panel->SetMaxSize(wxSize(-1, FromDIP(same_height)));
m_right_first_text_panel->SetMaxSize(wxSize(-1, FromDIP(same_height)));
// content_sizer
wxSizer *content_ams_sizer = new wxBoxSizer(wxVERTICAL);
m_right_split_ams_sizer = create_split_sizer(m_right_marea_panel, _L("Right AMS"));
m_right_split_ext_sizer = create_split_sizer(m_right_marea_panel, _L("External"));
content_ams_sizer->Add(m_right_split_ams_sizer, 0, wxEXPAND, 0);
content_ams_sizer->Add(m_sizer_ams_basket_right, 0, wxEXPAND | wxTOP, FromDIP(8));
content_ams_sizer->Add(m_right_split_ext_sizer, 0, wxEXPAND | wxTOP, FromDIP(8));
content_ams_sizer->Add(m_right_extra_slot, 0, wxEXPAND | wxTOP, FromDIP(8));
wxSizer *content_sizer = new wxBoxSizer(wxHORIZONTAL);
content_sizer->Add(content_ams_sizer, 1, wxEXPAND | wxLEFT);
m_flush_warning_panel = new DevIconLabel(m_right_marea_panel, "warning", ""); // Orca: dev_warning icon absent; use the shipped generic warning glyph
m_flush_warning_panel->SetAllBackgroundColor(StateColor::darkModeColorFor("#FFFFE0"));
m_flush_warning_panel->GetLabelItem()->SetForegroundColour(StateColor::darkModeColorFor("#F09A17"));
m_flush_warning_panel->Show(false);
m_sizer_ams_right->Add(m_right_first_text_panel, 0, wxEXPAND | wxBOTTOM | wxTOP, FromDIP(8));
m_sizer_ams_right->Add(m_flush_warning_panel, 0, wxBOTTOM | wxALIGN_LEFT, FromDIP(8));
m_sizer_ams_right->Add(content_sizer, 0, wxEXPAND, 0);
m_rack_nozzle_select = new wgtDeviceNozzleRackSelect(m_scrolled_window);
m_rack_nozzle_select->Bind(EVT_NOZZLE_SELECT_CHANGED, &AmsMapingPopup::OnNozzleMappingSelected, this);
m_rack_nozzle_select->Bind(EVT_NOZZLE_SELECT_CLICKED, [this](wxCommandEvent &e) { this->Dismiss(); });
m_rack_nozzle_select->Show(false);
m_ams_tips_msg_panel = new wgtMsgPanel(m_scrolled_window);
m_left_marea_panel->SetSizer(m_sizer_ams_left);
m_right_marea_panel->SetSizer(m_sizer_ams_right);
m_sizer_ams_v = new wxBoxSizer(wxVERTICAL);
m_split_line_panel = new wxPanel(m_scrolled_window, wxID_ANY, wxDefaultPosition, wxSize(FromDIP(1), -1));
m_split_line_panel->SetBackgroundColour(*wxWHITE);
m_split_line_panel->Bind(wxEVT_PAINT, [this](wxPaintEvent& evt) {
wxPaintDC dc(m_split_line_panel);
dc.SetPen(wxPen(wxColour(0xAC, 0xAC, 0xAC), 1, wxPENSTYLE_SHORT_DASH));
dc.DrawLine(0, FromDIP(20), 0, m_sizer_ams->GetSize().GetHeight());
});
//m_sizer_ams->Add(m_left_marea_panel, 0, wxEXPAND, FromDIP(0));
m_sizer_ams->Add(m_left_marea_panel, 0, wxRIGHT, FromDIP(10));
m_sizer_ams->Add(m_split_line_panel, 0, wxEXPAND | wxLEFT | wxRIGHT, FromDIP(7));
m_sizer_ams->Add(m_right_marea_panel, 0, wxEXPAND | wxLEFT, FromDIP(10));
m_sizer_ams_v->Add(m_reset_btn, 0, wxALIGN_RIGHT);
m_sizer_ams_v->Add(m_sizer_ams, 0, wxEXPAND | wxBOTTOM, FromDIP(30));
m_sizer_ams_v->AddStretchSpacer();
m_sizer_ams_v->Add(m_ams_tips_msg_panel, 0, wxEXPAND | wxBottom, FromDIP(10));
m_sizer_main_h->Add(m_sizer_ams_v, 0, wxEXPAND | wxRIGHT, FromDIP(10));
m_sizer_main_h->Add(m_rack_nozzle_select, 0, wxEXPAND | wxTOP | wxLEFT, FromDIP(15));
m_scrolled_window->SetSizer(m_sizer_main_h);
m_sizer_main->Add(title_panel, 0, wxEXPAND | wxALL, FromDIP(2));
m_sizer_main->Add(m_scrolled_window, 1, wxEXPAND | wxLEFT | wxRIGHT, FromDIP(14));
m_sizer_main->Add( 0, 0, 0, wxTOP, FromDIP(14));
SetSizer(m_sizer_main);
Layout();
Fit();
Bind(wxEVT_SHOW, [this](wxShowEvent& e) {
if (e.IsShown() && m_parent_item)
{
auto show_pos = m_parent_item->ClientToScreen(wxPoint(0, 0));
int display_idx = wxDisplay::GetFromWindow(m_parent_item);
if (display_idx == wxNOT_FOUND)
display_idx = 0;
wxRect screen_size = wxDisplay(display_idx).GetClientArea();
auto parent_size = m_parent_item->GetRect();
auto content_size = m_sizer_main_h->GetMinSize();
int popup_width = content_size.x + FromDIP(28);
int popup_height = content_size.y;
wxSize popup_size(popup_width, popup_height);
// Horizontal Direction Processing
if (show_pos.x + popup_size.x > screen_size.GetRight())
{
show_pos.x = screen_size.GetRight() - popup_size.x;
}
//if popup size bigger than screen
if (show_pos.x < screen_size.GetLeft())
{
show_pos.x = screen_size.GetLeft();
m_scrolled_window->SetMaxSize(wxSize(screen_size.GetWidth(), popup_height));
m_scrolled_window->SetMinSize(wxSize(screen_size.GetWidth(), popup_height));
m_scrolled_window->SetScrollRate(FromDIP(10), FromDIP(10));
}
else
{
m_scrolled_window->SetMaxSize(wxSize(popup_width, popup_height));
m_scrolled_window->SetMinSize(wxSize(popup_width, popup_height));
m_scrolled_window->SetScrollRate(0, FromDIP(10));
}
//Vertical Direction Processing
int available_height_below = screen_size.GetBottom() - (show_pos.y + parent_size.height);
int available_height_above = show_pos.y - screen_size.GetTop();
if (popup_size.y <= available_height_below)
{
show_pos.y = show_pos.y + parent_size.height;
}
else if (popup_size.y <= available_height_above)
{
show_pos.y = show_pos.y - popup_size.y - FromDIP(34) - FromDIP(14);// title_height = FromDIP(30) + FromDIP(4) padding = FromDIP(14)
}
else
{
int max_available_height;
if (available_height_below >= available_height_above) {
show_pos.y = show_pos.y + parent_size.height;
max_available_height = available_height_below;
} else {
show_pos.y = screen_size.GetTop();
max_available_height = available_height_above;
}
int title_and_padding = FromDIP(30) + FromDIP(4) + FromDIP(14);
int max_scroll_height = max_available_height - title_and_padding;
m_scrolled_window->SetMaxSize(wxSize(m_scrolled_window->GetMaxSize().x,max_scroll_height));
}
Layout();
Fit();
this->Move(show_pos);
}
});
}
void AmsMapingPopup::reset_ams_info()
{
if (m_reset_callback) {
m_reset_callback(m_material_index);
}
}
void AmsMapingPopup::set_reset_callback(ResetCallback callback) {
m_reset_callback = callback;
}
void AmsMapingPopup::show_reset_button() {
m_reset_btn->Show();
}
// Orca: kept surface for the reverse-direction SelectMachine — this helper (dropped by the reference)
// is still consumed by SelectMachine, so it stays as a permanent compatibility surface.
std::vector<TrayData> AmsMapingPopup::parse_ams_mapping(const std::map<std::string, DevAms*, NumericStrCompare>& amsList)
{
std::vector<TrayData> m_tray_data;
for (auto ams_iter = amsList.begin(); ams_iter != amsList.end(); ams_iter++) {
BOOST_LOG_TRIVIAL(trace) << "ams_mapping ams id " << ams_iter->first.c_str();
auto ams_indx = atoi(ams_iter->first.c_str());
DevAms* ams_group = ams_iter->second;
std::map<std::string, DevAmsTray*>::const_iterator tray_iter;
for (tray_iter = ams_group->GetTrays().cbegin(); tray_iter != ams_group->GetTrays().cend(); tray_iter++) {
DevAmsTray* tray_data = tray_iter->second;
TrayData td;
td.id = ams_indx * AMS_TOTAL_COUNT + atoi(tray_data->id.c_str());
if (!tray_data->is_exists) {
td.type = EMPTY;
} else {
if (!tray_data->is_tray_info_ready()) {
td.type = THIRD;
} else {
td.type = NORMAL;
td.remain = tray_data->remain;
td.colour = DevAmsTray::decode_color(tray_data->color);
td.name = tray_data->get_display_filament_type();
td.filament_type = tray_data->get_filament_type();
}
}
m_tray_data.push_back(td);
}
}
return m_tray_data;
}
void AmsMapingPopup::msw_rescale()
{
m_left_extra_slot->msw_rescale();
m_right_extra_slot->msw_rescale();
for (auto item : m_mapping_item_list) { item->msw_rescale(); }
for (auto container : m_amsmapping_container_list) { container->msw_rescale(); }
m_flush_warning_panel->Rescale();
m_rack_nozzle_select->Rescale();
Fit();
Refresh();
};
void AmsMapingPopup::set_sizer_title(wxBoxSizer *sizer, wxString text) {
if (!sizer) { return; }
wxSizerItemList items = sizer->GetChildren();
for (wxSizerItemList::iterator it = items.begin(); it != items.end(); ++it) {
wxSizerItem *item = *it;
auto temp_label = dynamic_cast<Label *>((item->GetWindow()));
if (temp_label) {
temp_label->SetLabel(text);
break;
}
}
}
wxBoxSizer *AmsMapingPopup::create_split_sizer(wxWindow *parent, wxString text)
{
wxBoxSizer* sizer_split_ams = new wxBoxSizer(wxHORIZONTAL);
auto ams_title_text = new Label(parent, text);
ams_title_text->SetFont(::Label::Body_13);
ams_title_text->SetBackgroundColour(*wxWHITE);
ams_title_text->SetForegroundColour(0x909090);
auto m_split_left_line = new wxPanel(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL);
m_split_left_line->SetBackgroundColour(0xeeeeee);
m_split_left_line->SetMinSize(wxSize(-1, 1));
m_split_left_line->SetMaxSize(wxSize(-1, 1));
sizer_split_ams->Add(0, 0, 0, wxEXPAND, 0);
sizer_split_ams->Add(ams_title_text, 0, wxALIGN_CENTER, 0);
sizer_split_ams->Add(m_split_left_line, 1, wxALIGN_CENTER_VERTICAL | wxEXPAND, 0);
return sizer_split_ams;
}
void AmsMapingPopup::update_materials_list(std::vector<std::string> list)
{
m_materials_list = list;
}
void AmsMapingPopup::set_tag_texture(std::string texture)
{
m_tag_material = texture;
}
bool AmsMapingPopup::is_match_material(std::string material) const
{
return m_tag_material == material ? true : false;
}
void AmsMapingPopup::on_left_down(wxMouseEvent &evt)
{
auto pos = ClientToScreen(evt.GetPosition());
{//deal m_reset_btn
auto& item = m_reset_btn;
auto p_rect = item->ClientToScreen(wxPoint(0, 0));
auto left = item->GetSize();
if (pos.x > p_rect.x && pos.y > p_rect.y && pos.x < (p_rect.x + item->GetSize().x) && pos.y < (p_rect.y + item->GetSize().y)) {
reset_ams_info();
evt.StopPropagation();
return;
}
}
for (MappingItem *item : m_mapping_item_list) {
auto p_rect = item->ClientToScreen(wxPoint(0, 0));
auto left = item->GetSize();
if (pos.x > p_rect.x && pos.y > p_rect.y && pos.x < (p_rect.x + item->GetSize().x) && pos.y < (p_rect.y + item->GetSize().y)) {
if (item->m_tray_data.type == TrayType::NORMAL) {
if (!m_ext_mapping_filatype_check && (item->m_ams_id == VIRTUAL_TRAY_MAIN_ID || item->m_ams_id == VIRTUAL_TRAY_DEPUTY_ID)) {
// Do nothing
} else {
if(!is_match_material(item->m_tray_data.filament_type)) { return; }
}
}
if (item->m_tray_data.type == TrayType::EMPTY) return;
if (m_show_type == ShowType::LEFT_AND_RIGHT_DYNAMIC && devPrinterUtil::IsVirtualSlot(item->m_ams_id)) return;
if ((m_show_type == ShowType::LEFT && item->GetParent()->GetName() == "left") ||
(m_show_type == ShowType::RIGHT && item->GetParent()->GetName() == "right") ||
m_show_type == ShowType::LEFT_AND_RIGHT ||
m_show_type == ShowType::LEFT_AND_RIGHT_DYNAMIC) {
item->send_event(m_current_filament_id);
Dismiss();
break;
}
}
}
evt.Skip();
}
#ifdef __APPLE__
void AmsMapingPopup::on_mouse_move(wxMouseEvent &evt)
{
auto pos = ClientToScreen(evt.GetPosition());
wxString tip_text;
wxPoint tip_pos;
for (MappingItem *item : m_mapping_item_list) {
auto origin = item->ClientToScreen(wxPoint(0, 0));
auto size = item->GetSize();
if (pos.x >= origin.x && pos.y >= origin.y && pos.x < origin.x + size.x && pos.y < origin.y + size.y)
{
auto *tip = item->GetToolTip();
if (tip && !tip->GetTip().IsEmpty())
{
tip_text = tip->GetTip();
tip_pos = wxPoint(origin.x, origin.y + size.y);
}
break;
}
}
if (!tip_text.IsEmpty()) {
if (!m_tip_popup)
{
m_tip_popup = new wxPopupWindow(this);
m_tip_popup->SetBackgroundColour(wxColour(255, 255, 255));
auto *sizer = new wxBoxSizer(wxVERTICAL);
// Use the project Label with pixel-width, CJK-aware wrapping instead
// of a bare wxStaticText, whose Wrap() only breaks at spaces and so
// leaves space-less Chinese text on a single overflowing line.
m_tip_label = new Label(m_tip_popup, wxEmptyString, LB_AUTO_WRAP);
m_tip_label->SetMaxSize(wxSize(FromDIP(400), -1));
m_tip_label->SetForegroundColour(*wxBLACK);
sizer->Add(m_tip_label, 0, wxALL, 4);
m_tip_popup->SetSizer(sizer);
m_tip_popup->Bind(wxEVT_IDLE, [this](wxIdleEvent &) {
if (!IsShown() && m_tip_popup) {
m_tip_popup->Destroy();
m_tip_popup = nullptr;
m_tip_label = nullptr;
}
});
}
if (m_tip_label->GetLabel() != tip_text) {
m_tip_label->SetLabel(tip_text);
m_tip_label->Wrap(FromDIP(400));
m_tip_popup->Layout();
m_tip_popup->Fit();
}
m_tip_popup->SetPosition(wxPoint(tip_pos.x, tip_pos.y));
if (!m_tip_popup->IsShown())
m_tip_popup->Show();
} else {
if (m_tip_popup && m_tip_popup->IsShown()) m_tip_popup->Hide();
}
}
#endif
void AmsMapingPopup::OnDismiss()
{
#ifdef __APPLE__
if (m_tip_popup && m_tip_popup->IsShown ())
m_tip_popup->Hide();
#endif
}
bool AmsMapingPopup::ProcessLeftDown(wxMouseEvent &event)
{
return PopupWindow::ProcessLeftDown(event);
}
void AmsMapingPopup::paintEvent(wxPaintEvent &evt)
{
wxPaintDC dc(this);
dc.SetPen(wxPen(StateColor::darkModeColorFor(wxColour("#009688")), FromDIP(2))); // Orca: colorful accent border for separation (dark-mode aware)
dc.SetBrush(*wxTRANSPARENT_BRUSH);
dc.DrawRoundedRectangle(0, 0, GetSize().x, GetSize().y, 0);
}
void AmsMapingPopup::OnNozzleMappingSelected(wxCommandEvent& evt)
{
if (auto ptr = m_rack.lock()) {
MachineObject* obj = ptr->GetNozzleSystem()->GetOwner();
obj->get_nozzle_mapping_result()->SetManualNozzleMappingByFila(m_current_filament_id, m_rack_nozzle_select->GetSelectedNozzlePosID());
update_flush_waste(obj);
}
evt.Skip();
Dismiss();
}
void AmsMapingPopup::update_flush_waste(MachineObject* obj)
{
if (!obj) {
m_flush_warning_panel->Hide();
return;
};
float flush_waste_base = obj->get_nozzle_mapping_result()->GetFlushWeightBase();
float flush_waste_current = obj->get_nozzle_mapping_result()->GetFlushWeightCurrent();
if ((flush_waste_base != -1) && (flush_waste_current != -1) && flush_waste_current > flush_waste_base){
m_flush_warning_panel->SetLabel(wxString::Format(_L("Printing with the current nozzle may produce an extra %0.2f g of waste."), flush_waste_current - flush_waste_base));
m_flush_warning_panel->Show();
} else {
m_flush_warning_panel->Hide();
}
}
MappingItem::MappingItem(wxWindow *parent)
: wxPanel(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize)
{
#ifdef __WINDOWS__
SetDoubleBuffered(true);
#endif //__WINDOWS__
m_transparent_mapping_item = ScalableBitmap(this, "transparent_mapping_item", FromDIP(60));
mapping_item_checked = ScalableBitmap(this, "mapping_item_checked", FromDIP(20));
SetBackgroundColour(StateColor::darkModeColorFor(*wxWHITE));
Bind(wxEVT_PAINT, &MappingItem::paintEvent, this);
}
MappingItem::~MappingItem()
{
}
void MappingItem::send_event(int fliament_id)
{
wxCommandEvent event(EVT_SET_FINISH_MAPPING);
event.SetInt(m_tray_data.id);
wxString param = wxString::Format("%d|%d|%d|%d|%s|%d|%d|%d", m_coloul.Red(), m_coloul.Green(), m_coloul.Blue(), m_coloul.Alpha(), m_tray_index, fliament_id,
m_tray_data.ams_id, m_tray_data.slot_id);
event.SetString(param);
if (send_win) {
event.SetEventObject(send_win);
wxPostEvent(send_win, event);
}
}
void MappingItem::msw_rescale()
{
m_transparent_mapping_item.msw_rescale();
mapping_item_checked.msw_rescale();
Refresh();
}
void MappingItem::paintEvent(wxPaintEvent &evt)
{
wxPaintDC dc(this);
render(dc);
// PrepareDC(buffdc);
// PrepareDC(dc);
}
static void _DrawRemainArea(const MappingItem *item, const TrayData &dd, bool support_remain_dect, wxDC &dc)
{
int to_paint_remain = dd.remain;
/*paint invalid data as 100*/
if (!support_remain_dect) { to_paint_remain = 100;}
if (0 > to_paint_remain || to_paint_remain > 100) { to_paint_remain = 100; }
wxSize size = item->GetSize();
int x_margin = item->FromDIP(4);
int y_margin = item->FromDIP(2);
int full_range_width = size.x;
/*range background*/
dc.SetPen(wxColour("#E4E4E4"));
dc.SetBrush(wxColour("#E4E4E4"));
int bg_height = item->FromDIP(6);
int bg_width = full_range_width - (2 * x_margin);
dc.DrawRoundedRectangle(x_margin, y_margin, bg_width, bg_height, item->FromDIP(2));
/*remain fill*/
if (!dd.name.empty())
{
dc.SetPen(dd.colour);
dc.SetBrush(dd.colour);
int border = item->FromDIP(1);
int remain_width = (bg_width - (2 * border)) * to_paint_remain / 100;
int remain_height = bg_height - (2 * border);
dc.DrawRoundedRectangle(x_margin + border, y_margin + border, remain_width, remain_height, item->FromDIP(2));
}
}
void MappingItem::render(wxDC &dc)
{
wxSize size = GetSize();
#ifdef __WXMSW__
wxMemoryDC memdc;
wxBitmap bmp(size.x, size.y);
memdc.SelectObject(bmp);
memdc.Blit({0, 0}, size, &dc, {0, 0});
{
wxGCDC dc2(memdc);
doRender(dc2);
}
memdc.SelectObject(wxNullBitmap);
dc.DrawBitmap(bmp, 0, 0);
#else
doRender(dc);
#endif
/*remain*/
auto top = 0;
if (m_to_paint_remain)
{
_DrawRemainArea(this, m_tray_data, m_support_remain_detect, dc);
top += get_remain_area_height();
}
// checked
if (m_checked)
{
dc.DrawBitmap(mapping_item_checked.bmp(), size.x - mapping_item_checked.GetBmpWidth() - FromDIP(4), top);
}
top += 0.5 * mapping_item_checked.GetBmpHeight();
// materials name
dc.SetFont(::Label::Head_12);
auto txt_colour = m_coloul.GetLuminance() < 0.6 ? *wxWHITE : wxColour(0x26, 0x2E, 0x30);
if (m_unmatch || m_name == "-" ) { txt_colour = wxColour(0xCE, 0xCE, 0xCE); }
// txt_colour = m_unmatch ? wxColour(0xCE, 0xCE, 0xCE) : txt_colour;
if (m_coloul.Alpha() == 0)
txt_colour = wxColour(0x26, 0x2E, 0x30);
if (!IsEnabled())
txt_colour = wxColour(0xCE, 0xCE, 0xCE);
dc.SetTextForeground(txt_colour);
//show a1
auto txt_size = dc.GetTextExtent(m_tray_index);
top += FromDIP(2);
dc.DrawText(m_tray_index, wxPoint((GetSize().x - txt_size.x) / 2, top));
//show materials name
top += txt_size.y + FromDIP(2);
m_name.size() > 4 ? dc.SetFont(::Label::Body_9) : dc.SetFont(::Label::Body_12);
if(m_name.size() > 5){
m_name = m_name.substr(0,5) + "...";
}
txt_size = dc.GetTextExtent(m_name);
dc.DrawText(m_name, wxPoint((GetSize().x - txt_size.x) / 2, top));
}
void MappingItem::set_data(const wxString &tag_name, wxColour colour, wxString name, bool remain_dect, TrayData data, bool unmatch, std::optional<wxString> tooltip_opt)
{
m_unmatch = unmatch;
m_tray_data = data;
if (m_coloul != colour || m_name != name || (m_support_remain_detect != remain_dect)) {
m_coloul = colour;
m_name = name;
m_support_remain_detect = remain_dect;
m_to_paint_remain = (m_tray_data.ams_id != VIRTUAL_TRAY_MAIN_ID && m_tray_data.ams_id != VIRTUAL_TRAY_DEPUTY_ID);
Refresh();
}
if (tooltip_opt.has_value())
{
SetToolTip(tooltip_opt.value());
}
else if (m_unmatch || (m_name == "-"))
{
if (m_unmatch) {
bool is_external_spool = (m_tray_data.ams_id == VIRTUAL_TRAY_MAIN_ID || m_tray_data.ams_id == VIRTUAL_TRAY_DEPUTY_ID);
if (!m_name.IsEmpty() && (m_name != "-")) {
wxString msg;
if (is_external_spool) {
msg = wxString::Format(_L("Tips: the filament type(%s) does not match with the filament type(%s) in the slicing file. "
"If you want to use this slot, you can install %s instead of %s and change slot information on the 'Device' page."),
m_name, tag_name, tag_name, m_name);
} else {
msg = wxString::Format(_L("Cannot select: the filament type(%s) does not match with the filament type(%s) in the slicing file. "
"If you want to use this slot, you can install %s instead of %s and change slot information on the 'Device' page."),
m_name, tag_name, tag_name, m_name);
}
SetToolTip(msg);
} else {
const wxString &msg = wxString::Format(_L("Cannot select: the slot is empty or undefined. If you want to use this slot, you can install %s and change slot information on the 'Device' page."), tag_name);
SetToolTip(msg);
}
} else {
SetToolTip(_L("Cannot select: No filament loaded in current slot."));
}
}
else
{
SetToolTip(wxEmptyString);
}
}
void MappingItem::set_checked(bool checked)
{
if (m_checked != checked)
{
m_checked = checked;
Refresh();
}
}
void MappingItem::doRender(wxDC &dc)
{
wxSize size = GetSize();
wxColour color = m_coloul;
change_the_opacity(color);
if (!IsThisEnabled()) { color = wxColour(0xEE, 0xEE, 0xEE); }
dc.SetPen(color);
dc.SetBrush(wxBrush(color));
//draw a rectangle based on the material color, single color or muti color processing
if (m_tray_data.material_cols.size() > 1 && !m_unmatch) {
int left = 0;
int gwidth = std::round(MAPPING_ITEM_REAL_SIZE.x / (m_tray_data.material_cols.size() - 1));
//gradient
if (m_tray_data.ctype == 0) {
for (int i = 0; i < m_tray_data.material_cols.size() - 1; i++) {
auto rect = wxRect(left, (size.y - MAPPING_ITEM_REAL_SIZE.y) / 2 + get_remain_area_height(), MAPPING_ITEM_REAL_SIZE.x, MAPPING_ITEM_REAL_SIZE.y);
fill_gradient_rect_east(dc, rect, m_tray_data.material_cols[i], m_tray_data.material_cols[i + 1]);
left += gwidth;
}
}
else {
int cols_size = m_tray_data.material_cols.size();
for (int i = 0; i < cols_size; i++) {
dc.SetBrush(wxBrush(m_tray_data.material_cols[i]));
float x = (float)MAPPING_ITEM_REAL_SIZE.x * i / cols_size;
dc.DrawRectangle(x, (size.y - MAPPING_ITEM_REAL_SIZE.y) / 2 + get_remain_area_height(), (float) MAPPING_ITEM_REAL_SIZE.x / cols_size, MAPPING_ITEM_REAL_SIZE.y);
}
}
}
else if (color.Alpha() == 0) {
dc.DrawBitmap(m_transparent_mapping_item.bmp(), 0, (size.y - MAPPING_ITEM_REAL_SIZE.y) / 2 + get_remain_area_height());
}
else {
dc.DrawRectangle(0, (size.y - MAPPING_ITEM_REAL_SIZE.y) / 2 + get_remain_area_height(), MAPPING_ITEM_REAL_SIZE.x, MAPPING_ITEM_REAL_SIZE.y);
}
wxColour side_colour = wxColour("#E4E4E4");
dc.SetPen(side_colour);
dc.SetBrush(wxBrush(side_colour));
dc.DrawRectangle(0, get_remain_area_height(), FromDIP(4), size.y);
dc.DrawRectangle(size.x - FromDIP(4), get_remain_area_height(), FromDIP(4), size.y);
}
int MappingItem::get_remain_area_height() const
{
if (m_to_paint_remain) { return FromDIP(10);}
return 0;
}
AmsMapingTipPopup::AmsMapingTipPopup(wxWindow *parent)
:PopupWindow(parent, wxBORDER_NONE)
{
SetBackgroundColour(*wxWHITE);
wxBoxSizer *m_sizer_main = new wxBoxSizer(wxVERTICAL);
m_sizer_main->Add(0, 0, 1, wxTOP, FromDIP(28));
wxBoxSizer *m_sizer_body = new wxBoxSizer(wxHORIZONTAL);
m_sizer_body->Add(0, 0, 0, wxEXPAND | wxLEFT, FromDIP(20));
m_panel_enable_ams = new wxPanel(this, wxID_ANY, wxDefaultPosition, wxSize(FromDIP(220), -1), wxTAB_TRAVERSAL);
m_panel_enable_ams->SetBackgroundColour(*wxWHITE);
wxBoxSizer *sizer_enable_ams = new wxBoxSizer(wxVERTICAL);
m_title_enable_ams = new wxStaticText(m_panel_enable_ams, wxID_ANY, _L("Enable AMS"), wxDefaultPosition, wxDefaultSize, 0);
m_title_enable_ams->SetForegroundColour(*wxBLACK);
m_title_enable_ams->SetBackgroundColour(*wxWHITE);
m_title_enable_ams->Wrap(-1);
sizer_enable_ams->Add(m_title_enable_ams, 0, 0, 0);
m_tip_enable_ams = new wxStaticText(m_panel_enable_ams, wxID_ANY, _L("Print with filament in the AMS"), wxDefaultPosition, wxDefaultSize, 0); // Orca: kept string (existing translation)
m_tip_enable_ams->SetMinSize(wxSize(FromDIP(200), FromDIP(50)));
m_tip_enable_ams->Wrap(FromDIP(200));
m_tip_enable_ams->SetForegroundColour(*wxBLACK);
m_tip_enable_ams->SetBackgroundColour(*wxWHITE);
sizer_enable_ams->Add(m_tip_enable_ams, 0, wxTOP, 8);
wxBoxSizer *sizer_enable_ams_img;
sizer_enable_ams_img = new wxBoxSizer(wxVERTICAL);
auto img_enable_ams = new wxStaticBitmap(m_panel_enable_ams, wxID_ANY, create_scaled_bitmap("monitor_upgrade_ams", this, 108), wxDefaultPosition,
wxSize(FromDIP(118), FromDIP(108)), 0);
sizer_enable_ams_img->Add(img_enable_ams, 0, wxALIGN_CENTER_HORIZONTAL, 0);
sizer_enable_ams->Add(sizer_enable_ams_img, 1, wxEXPAND | wxTOP, FromDIP(20));
m_panel_enable_ams->SetSizer(sizer_enable_ams);
m_panel_enable_ams->Layout();
m_sizer_body->Add(m_panel_enable_ams, 0, 0, 0);
m_split_lines = new wxPanel(this, wxID_ANY, wxDefaultPosition, wxSize(1, FromDIP(150)), wxTAB_TRAVERSAL);
m_split_lines->SetBackgroundColour(wxColour(238, 238, 238));
m_sizer_body->Add(m_split_lines, 0, wxALIGN_CENTER_VERTICAL | wxLEFT | wxRIGHT, FromDIP(10));
m_panel_disable_ams = new wxPanel(this, wxID_ANY, wxDefaultPosition, wxSize(FromDIP(220), -1), wxTAB_TRAVERSAL);
m_panel_disable_ams->SetBackgroundColour(*wxWHITE);
wxBoxSizer *sizer_disable_ams;
sizer_disable_ams = new wxBoxSizer(wxVERTICAL);
m_title_disable_ams = new wxStaticText(m_panel_disable_ams, wxID_ANY, _L("Disable AMS"), wxDefaultPosition, wxDefaultSize, 0);
m_title_disable_ams->SetBackgroundColour(*wxWHITE);
m_title_disable_ams->SetForegroundColour(*wxBLACK);
m_title_disable_ams->Wrap(-1);
sizer_disable_ams->Add(m_title_disable_ams, 0, 0, 0);
m_tip_disable_ams = new wxStaticText(m_panel_disable_ams, wxID_ANY, _L("Print with filament on external spool"), wxDefaultPosition, wxDefaultSize, 0); // Orca: kept string (existing translation)
m_tip_disable_ams->SetMinSize(wxSize(FromDIP(200), FromDIP(50)));
m_tip_disable_ams->Wrap(FromDIP(200));
m_tip_disable_ams->SetForegroundColour(*wxBLACK);
m_tip_disable_ams->SetBackgroundColour(*wxWHITE);
sizer_disable_ams->Add(m_tip_disable_ams, 0, wxTOP, FromDIP(8));
wxBoxSizer *sizer_disable_ams_img;
sizer_disable_ams_img = new wxBoxSizer(wxVERTICAL);
auto img_disable_ams = new wxStaticBitmap(m_panel_disable_ams, wxID_ANY, create_scaled_bitmap("disable_ams_demo_icon", this, 95), wxDefaultPosition,
wxSize(FromDIP(95), FromDIP(109)), 0);
sizer_disable_ams_img->Add(img_disable_ams, 0, wxALIGN_CENTER_HORIZONTAL, 0);
sizer_disable_ams->Add(sizer_disable_ams_img, 1, wxEXPAND | wxTOP, FromDIP(20));
m_panel_disable_ams->SetSizer(sizer_disable_ams);
m_panel_disable_ams->Layout();
m_sizer_body->Add(m_panel_disable_ams, 0, 0, 0);
m_sizer_body->Add(0, 0, 0, wxEXPAND | wxRIGHT, FromDIP(20));
m_sizer_main->Add(m_sizer_body, 0, wxEXPAND, 0);
m_sizer_main->Add(0, 0, 0, wxEXPAND | wxTOP, FromDIP(28));
this->SetSizer(m_sizer_main);
this->Layout();
this->Fit();
Bind(wxEVT_PAINT, &AmsMapingTipPopup::paintEvent, this);
}
void AmsMapingTipPopup::paintEvent(wxPaintEvent &evt)
{
wxPaintDC dc(this);
dc.SetPen(wxColour(0xAC, 0xAC, 0xAC));
dc.SetBrush(*wxTRANSPARENT_BRUSH);
dc.DrawRoundedRectangle(0, 0, GetSize().x, GetSize().y, 0);
}
void AmsMapingTipPopup::OnDismiss() {}
bool AmsMapingTipPopup::ProcessLeftDown(wxMouseEvent &event) {
return PopupWindow::ProcessLeftDown(event); }
AmsHumidityTipPopup::AmsHumidityTipPopup(wxWindow* parent)
:PopupWindow(parent, wxBORDER_NONE)
{
SetBackgroundColour(*wxWHITE);
wxBoxSizer* main_sizer = new wxBoxSizer(wxVERTICAL);
close_img = ScalableBitmap(this, "hum_popup_close", 24);
m_staticText = new Label(this, _L("Current AMS humidity"));
m_staticText->SetFont(::Label::Head_24);
humidity_level_list = new AmsHumidityLevelList(this);
curr_humidity_img = new wxStaticBitmap(this, wxID_ANY, create_scaled_bitmap("hum_level1_light", this, 132), wxDefaultPosition, wxSize(FromDIP(132), FromDIP(132)), 0);
// Orca: kept the grammatically-corrected desiccant note (existing translation)
m_staticText_note = new Label(this, _L("Please change the desiccant when it is too wet. The indicator may not represent accurately in following cases: when the lid is open or the desiccant pack is changed. It takes a few hours to absorb the moisture, and low temperatures also slow down the process."));
m_staticText_note->SetMinSize(wxSize(FromDIP(680), -1));
m_staticText_note->SetMaxSize(wxSize(FromDIP(680), -1));
m_staticText_note->Wrap(FromDIP(680));
Bind(wxEVT_LEFT_UP, [this](auto& e) {
auto rect = ClientToScreen(wxPoint(0, 0));
auto close_left = rect.x + GetSize().x - close_img.GetBmpWidth() - FromDIP(38);
auto close_right = close_left + close_img.GetBmpWidth();
auto close_top = rect.y + FromDIP(24);
auto close_bottom = close_top + close_img.GetBmpHeight();
auto mouse_pos = ClientToScreen(e.GetPosition());
if (mouse_pos.x > close_left
&& mouse_pos.y > close_top
&& mouse_pos.x < close_right
&& mouse_pos.y < close_bottom
)
{
Dismiss();
}
});
main_sizer->Add(0, 0, 0, wxTOP, FromDIP(24));
main_sizer->Add(m_staticText, 0, wxALIGN_CENTER, 0);
main_sizer->Add(0, 0, 0, wxEXPAND | wxTOP, FromDIP(28));
main_sizer->Add(curr_humidity_img, 0, wxALIGN_CENTER|wxLEFT|wxRIGHT, FromDIP(35));
main_sizer->Add(0, 0, 0, wxEXPAND | wxTOP, FromDIP(15));
main_sizer->Add(humidity_level_list, 0, wxALIGN_CENTER|wxLEFT|wxRIGHT, FromDIP(35));
main_sizer->Add(0, 0, 0, wxEXPAND | wxTOP, FromDIP(6));
main_sizer->Add(m_staticText_note, 0, wxALIGN_CENTER, 0);
main_sizer->Add(0, 0, 0, wxEXPAND | wxTOP, FromDIP(5));
main_sizer->Add(0, 0, 0, wxEXPAND | wxTOP, FromDIP(25));
SetSizer(main_sizer);
Layout();
Fit();
Bind(wxEVT_PAINT, &AmsHumidityTipPopup::paintEvent, this);
wxGetApp().UpdateDarkUIWin(this);
}
void AmsHumidityTipPopup::set_humidity_level(int level)
{
if (0 < level && level < 6)
{
current_humidity_level = level;
std::string mode_string = wxGetApp().dark_mode() ? "_dark" : "_light";
curr_humidity_img->SetBitmap(create_scaled_bitmap("hum_level" + std::to_string(current_humidity_level) + mode_string, this, 132));
curr_humidity_img->Refresh();
curr_humidity_img->Update();
}
}
void AmsHumidityTipPopup::msw_rescale()
{
// close image
close_img.msw_rescale();
// current humidity level image
if (0 < current_humidity_level && current_humidity_level < 6)
{
std::string mode_string = wxGetApp().dark_mode() ? "_dark" : "_light";
curr_humidity_img->SetBitmap(create_scaled_bitmap("hum_level" + std::to_string(current_humidity_level) + mode_string, this, 132));
}
// the list
humidity_level_list->msw_rescale();
// refresh
Refresh();
}
void AmsHumidityTipPopup::paintEvent(wxPaintEvent& evt)
{
wxPaintDC dc(this);
render(dc);
}
void AmsHumidityTipPopup::render(wxDC& dc)
{
#ifdef __WXMSW__
wxSize size = GetSize();
wxMemoryDC memdc;
wxBitmap bmp(size.x, size.y);
memdc.SelectObject(bmp);
memdc.Blit({ 0, 0 }, size, &dc, { 0, 0 });
{
wxGCDC dc2(memdc);
doRender(dc2);
}
memdc.SelectObject(wxNullBitmap);
dc.DrawBitmap(bmp, 0, 0);
#else
doRender(dc);
#endif
}
void AmsHumidityTipPopup::doRender(wxDC& dc)
{
//close
dc.DrawBitmap(close_img.bmp(), GetSize().x - close_img.GetBmpWidth() - FromDIP(38), FromDIP(24));
//background
dc.SetPen(wxColour(0xAC, 0xAC, 0xAC));
dc.SetBrush(*wxTRANSPARENT_BRUSH);
dc.DrawRoundedRectangle(0, 0, GetSize().x, GetSize().y, 0);
}
AmsTutorialPopup::AmsTutorialPopup(wxWindow* parent)
:PopupWindow(parent, wxBORDER_NONE)
{
Bind(wxEVT_PAINT, &AmsTutorialPopup::paintEvent, this);
SetBackgroundColour(*wxWHITE);
wxBoxSizer* sizer_main;
sizer_main = new wxBoxSizer(wxVERTICAL);
text_title = new Label(this, Label::Head_14, _L("Configure which AMS slot should be used for a filament used in the print job.")); // Orca: kept string (existing translation)
text_title->SetSize(wxSize(FromDIP(350), -1));
text_title->Wrap(FromDIP(350));
sizer_main->Add(text_title, 0, wxALIGN_CENTER | wxTOP, 18);
sizer_main->Add(0, 0, 0, wxTOP, 30);
wxBoxSizer* sizer_top;
sizer_top = new wxBoxSizer(wxHORIZONTAL);
img_top = new wxStaticBitmap(this, wxID_ANY, create_scaled_bitmap("ams_item_examples", this, 30), wxDefaultPosition, wxSize(FromDIP(50), FromDIP(30)), 0);
sizer_top->Add(img_top, 0, wxALIGN_CENTER, 0);
sizer_top->Add(0, 0, 0, wxLEFT, 10);
wxBoxSizer* sizer_top_tips = new wxBoxSizer(wxVERTICAL);
wxBoxSizer* sizer_tip_top = new wxBoxSizer(wxHORIZONTAL);
arrows_top = new wxStaticBitmap(this, wxID_ANY, create_scaled_bitmap("ams_arrow", this, 8), wxDefaultPosition, wxSize(FromDIP(24), FromDIP(8)), 0);
sizer_tip_top->Add(arrows_top, 0, wxALIGN_CENTER, 0);
tip_top = new wxStaticText(this, wxID_ANY, _L("Filament used in this print job"), wxDefaultPosition, wxDefaultSize, 0);
tip_top->SetForegroundColour(wxColour("#686868"));
sizer_tip_top->Add(tip_top, 0, wxALL, 0);
sizer_top_tips->Add(sizer_tip_top, 0, wxEXPAND, 0);
sizer_top_tips->Add(0, 0, 0, wxTOP, 6);
wxBoxSizer* sizer_tip_bottom = new wxBoxSizer(wxHORIZONTAL);
arrows_bottom = new wxStaticBitmap(this, wxID_ANY, create_scaled_bitmap("ams_arrow", this, 8), wxDefaultPosition, wxSize(FromDIP(24), FromDIP(8)), 0);
tip_bottom = new wxStaticText(this, wxID_ANY, _L("AMS slot used for this filament"), wxDefaultPosition, wxDefaultSize, 0);
tip_bottom->SetForegroundColour(wxColour("#686868"));
sizer_tip_bottom->Add(arrows_bottom, 0, wxALIGN_CENTER, 0);
sizer_tip_bottom->Add(tip_bottom, 0, wxALL, 0);
sizer_top_tips->Add(sizer_tip_bottom, 0, wxEXPAND, 0);
sizer_top->Add(sizer_top_tips, 0, wxALIGN_CENTER, 0);
wxBoxSizer* sizer_middle = new wxBoxSizer(wxHORIZONTAL);
img_middle= new wxStaticBitmap(this, wxID_ANY, create_scaled_bitmap("ams_item_examples", this, 30), wxDefaultPosition, wxSize(FromDIP(50), FromDIP(30)), 0);
sizer_middle->Add(img_middle, 0, wxALIGN_CENTER, 0);
tip_middle = new wxStaticText(this, wxID_ANY, _L("Click to select AMS slot manually"), wxDefaultPosition, wxDefaultSize, 0);
tip_middle->SetForegroundColour(wxColour("#686868"));
sizer_middle->Add(0, 0, 0,wxLEFT, 15);
sizer_middle->Add(tip_middle, 0, wxALIGN_CENTER, 0);
sizer_main->Add(sizer_top, 0, wxLEFT, 40);
sizer_main->Add(0, 0, 0, wxTOP, 10);
sizer_main->Add(sizer_middle, 0, wxLEFT, 40);
sizer_main->Add(0, 0, 0, wxTOP, 10);
img_botton = new wxStaticBitmap(this, wxID_ANY, create_scaled_bitmap("ams_mapping_examples", this, 87), wxDefaultPosition, wxDefaultSize, 0);
sizer_main->Add(img_botton, 0, wxLEFT | wxRIGHT, 40);
sizer_main->Add(0, 0, 0, wxTOP, 12);
SetSizer(sizer_main);
Layout();
Fit();
}
void AmsTutorialPopup::paintEvent(wxPaintEvent& evt)
{
wxPaintDC dc(this);
dc.SetPen(wxColour(0xAC, 0xAC, 0xAC));
dc.SetBrush(*wxTRANSPARENT_BRUSH);
dc.DrawRoundedRectangle(0, 0, GetSize().x, GetSize().y, 0);
}
void AmsTutorialPopup::OnDismiss() {}
bool AmsTutorialPopup::ProcessLeftDown(wxMouseEvent& event) {
return PopupWindow::ProcessLeftDown(event);
}
AmsIntroducePopup::AmsIntroducePopup(wxWindow* parent)
:PopupWindow(parent, wxBORDER_NONE)
{
Bind(wxEVT_PAINT, &AmsIntroducePopup::paintEvent, this);
SetBackgroundColour(*wxWHITE);
SetMinSize(wxSize(FromDIP(200), FromDIP(200)));
SetMaxSize(wxSize(FromDIP(200), FromDIP(200)));
wxBoxSizer* bSizer4 = new wxBoxSizer(wxVERTICAL);
m_staticText_top = new Label(this, _L("Do not Enable AMS"));
m_staticText_top->SetFont(::Label::Head_13);
// m_staticText_top->SetForegroundColour(wxColour("#323A3D"));
m_staticText_top->Wrap(-1);
bSizer4->Add(m_staticText_top, 0, wxALL, 5);
m_staticText_bottom = new Label(this, _L("Print using filament on external spool.")); // Orca: kept string (existing translation)
m_staticText_bottom->Wrap(-1);
m_staticText_bottom->SetFont(::Label::Body_13);
m_staticText_bottom->SetForegroundColour(wxColour("#6B6B6B"));
bSizer4->Add(m_staticText_bottom, 0, wxALL, 5);
wxBoxSizer* bSizer5;
bSizer5 = new wxBoxSizer(wxHORIZONTAL);
m_img_enable_ams = new wxStaticBitmap(this, wxID_ANY, create_scaled_bitmap("monitor_upgrade_ams", this, FromDIP(140)), wxDefaultPosition, wxDefaultSize, 0);
m_img_disable_ams = new wxStaticBitmap(this, wxID_ANY, create_scaled_bitmap("disable_ams_demo_icon", this, FromDIP(110)), wxDefaultPosition, wxDefaultSize, 0);
m_img_enable_ams->SetMinSize(wxSize(FromDIP(96), FromDIP(110)));
m_img_disable_ams->SetMinSize(wxSize(FromDIP(96), FromDIP(110)));
bSizer5->Add(m_img_enable_ams, 0, wxALIGN_CENTER, 0);
bSizer5->Add(m_img_disable_ams, 0, wxALIGN_CENTER, 0);
m_img_disable_ams->Hide();
m_img_disable_ams->Hide();
bSizer4->Add(bSizer5, 0, wxALIGN_CENTER | wxBOTTOM, FromDIP(1));
SetSizer(bSizer4);
Layout();
Fit();
wxGetApp().UpdateDarkUIWin(this);
}
void AmsIntroducePopup::set_mode(bool enable_ams)
{
if (enable_ams) {
m_staticText_top->SetLabelText(_L("Enable AMS"));
m_staticText_bottom->SetLabelText(_L("Print with filament in AMS")); // Orca: kept string (existing translation)
m_img_enable_ams->Show();
m_img_disable_ams->Hide();
}
else {
m_staticText_top->SetLabelText(_L("Do not Enable AMS"));
m_staticText_bottom->SetLabelText(_L("Print with filament on external spool")); // Orca: kept string (existing translation)
m_staticText_bottom->SetMinSize(wxSize(FromDIP(180), -1));
m_staticText_bottom->Wrap(FromDIP(180));
m_img_enable_ams->Hide();
m_img_disable_ams->Show();
}
Layout();
Fit();
}
void AmsIntroducePopup::paintEvent(wxPaintEvent& evt)
{
wxPaintDC dc(this);
dc.SetPen(wxColour(0xAC, 0xAC, 0xAC));
dc.SetBrush(*wxTRANSPARENT_BRUSH);
dc.DrawRoundedRectangle(0, 0, GetSize().x, GetSize().y, 0);
}
void AmsIntroducePopup::OnDismiss() {}
bool AmsIntroducePopup::ProcessLeftDown(wxMouseEvent& event) {
return PopupWindow::ProcessLeftDown(event);
}
MappingContainer::MappingContainer(wxWindow *parent, const wxString &ams_type, int slots_num)
: wxPanel(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize)
{
#ifdef __WINDOWS__
SetDoubleBuffered(true);
#endif //__WINDOWS__
SetBackgroundColour(StateColor::darkModeColorFor(*wxWHITE));
Bind(wxEVT_PAINT, &MappingContainer::paintEvent, this);
m_ams_type = ams_type;
m_slots_num = slots_num;
if (slots_num == 1)
{
ams_mapping_item_container = create_scaled_bitmap("ams_mapping_container_1", this, 82);
SetMinSize(wxSize(FromDIP(74), FromDIP(82)));
SetMaxSize(wxSize(FromDIP(74), FromDIP(82)));
}
else
{
ams_mapping_item_container = create_scaled_bitmap("ams_mapping_container_4", this, 82);
SetMinSize(wxSize(FromDIP(230), FromDIP(82)));
SetMaxSize(wxSize(FromDIP(230), FromDIP(82)));
}
}
MappingContainer::~MappingContainer()
{
}
void MappingContainer::msw_rescale()
{
if (m_slots_num == 1) {
ams_mapping_item_container = create_scaled_bitmap("ams_mapping_container_1", this, 82);
} else {
ams_mapping_item_container = create_scaled_bitmap("ams_mapping_container_4", this, 82);
}
Refresh();
}
void MappingContainer::paintEvent(wxPaintEvent &evt)
{
wxPaintDC dc(this);
render(dc);
}
void MappingContainer::render(wxDC& dc)
{
#ifdef __WXMSW__
wxSize size = GetSize();
wxMemoryDC memdc;
wxBitmap bmp(size.x, size.y);
memdc.SelectObject(bmp);
memdc.Blit({ 0, 0 }, size, &dc, { 0, 0 });
{
wxGCDC dc2(memdc);
doRender(dc2);
}
memdc.SelectObject(wxNullBitmap);
dc.DrawBitmap(bmp, 0, 0);
#else
doRender(dc);
#endif
}
void MappingContainer::doRender(wxDC& dc)
{
dc.DrawBitmap(ams_mapping_item_container, 0, 0);
dc.SetFont(::Label::Head_11);
auto size = GetSize();
auto extent = dc.GetTextExtent(m_ams_type);
dc.SetTextForeground(wxColour("#F1F1F1"));
dc.DrawText(m_ams_type, FromDIP(10), size.GetHeight() - extent.GetHeight());
}
AmsReplaceMaterialDialog::AmsReplaceMaterialDialog(wxWindow* parent)
: DPIDialog(parent, wxID_ANY, _L("Auto Refill"), wxDefaultPosition, wxDefaultSize, wxSYSTEM_MENU | wxCAPTION | wxCLOSE_BOX)
{
#ifdef __WINDOWS__
SetDoubleBuffered(true);
#endif //__WINDOWS__
SetBackgroundColour(*wxWHITE);
create();
wxGetApp().UpdateDlgDarkUI(this);
}
void AmsReplaceMaterialDialog::create()
{
SetSize(wxSize(FromDIP(445), -1));
SetMinSize(wxSize(FromDIP(445), -1));
SetMaxSize(wxSize(FromDIP(445), -1));
// set icon for dialog
std::string icon_path = (boost::format("%1%/images/OrcaSlicerTitle.ico") % resources_dir()).str();
SetIcon(wxIcon(encode_path(icon_path.c_str()), wxBITMAP_TYPE_ICO));
m_main_sizer = new wxBoxSizer(wxVERTICAL);
auto m_top_line = new wxPanel(this, wxID_ANY, wxDefaultPosition, wxSize(-1, 1), wxTAB_TRAVERSAL);
m_top_line->SetBackgroundColour(wxColour(166, 169, 170));
m_main_sizer->Add(m_top_line, 0, wxEXPAND, 0);
m_nozzle_btn_panel = new SwitchBoard(this, _L("Left"), _L("Right"), wxSize(FromDIP(126), FromDIP(26)));
m_nozzle_btn_panel->Hide();
m_nozzle_btn_panel->Connect(wxCUSTOMEVT_SWITCH_POS, wxCommandEventHandler(AmsReplaceMaterialDialog::on_nozzle_selected), NULL, this);
label_txt = new Label(this, _L("When the current material run out, the printer will continue to print in the following order."));
label_txt->SetFont(Label::Body_13);
label_txt->SetForegroundColour(StateColor::darkModeColorFor(wxColour("#323A3C")));
label_txt->SetMinSize(wxSize(FromDIP(380), -1));
label_txt->SetMaxSize(wxSize(FromDIP(380), -1));
label_txt->Wrap(FromDIP(380));
identical_filament = new Label(this, _L("Identical filament: same brand, type and color.")); // Orca: kept trailing period (existing translation)
identical_filament->SetFont(Label::Body_13);
identical_filament->SetForegroundColour(StateColor::darkModeColorFor(wxColour("#009688"))); // Orca: accent teal (not brand green)
m_scrollview_groups = new wxScrolledWindow(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxHSCROLL | wxVSCROLL);
m_scrollview_groups->SetScrollRate(5, 5);
//m_scrollview_groups->SetMinSize(wxSize(400, 400));
//m_scrollview_groups->SetMaxSize(wxSize(400, 400));
m_scrollview_sizer = new wxBoxSizer(wxVERTICAL);
m_groups_sizer = new wxWrapSizer( wxHORIZONTAL, wxWRAPSIZER_DEFAULT_FLAGS );
m_scrollview_sizer->Add( m_groups_sizer, 0, wxALIGN_CENTER, 0 );
m_scrollview_groups->SetSizer(m_scrollview_sizer);
m_scrollview_groups->Layout();
auto m_button_sizer = new wxBoxSizer(wxHORIZONTAL);
StateColor btn_bg_white(std::pair<wxColour, int>(AMS_CONTROL_DISABLE_COLOUR, StateColor::Disabled),
std::pair<wxColour, int>(AMS_CONTROL_DISABLE_COLOUR, StateColor::Pressed),
std::pair<wxColour, int>(AMS_CONTROL_DEF_BLOCK_BK_COLOUR, StateColor::Hovered),
std::pair<wxColour, int>(AMS_CONTROL_WHITE_COLOUR, StateColor::Normal));
StateColor btn_bd_white(std::pair<wxColour, int>(wxColour(255, 255, 254), StateColor::Disabled),
std::pair<wxColour, int>(wxColour(38, 46, 48), StateColor::Enabled));
StateColor btn_text_white(std::pair<wxColour, int>(wxColour(255, 255, 254), StateColor::Disabled),
std::pair<wxColour, int>(wxColour(38, 46, 48), StateColor::Enabled));
StateColor btn_bg_green(std::pair<wxColour, int>(wxColour(0, 137, 123), StateColor::Pressed), std::pair<wxColour, int>(wxColour(0, 150, 136), StateColor::Normal)); // Orca: accent teal button (not brand green)
m_button_sizer->Add( 0, 0, 1, wxEXPAND, 0 );
m_main_sizer->Add(0,0,0, wxTOP, FromDIP(12));
m_main_sizer->Add(m_nozzle_btn_panel,0, wxALIGN_CENTER_HORIZONTAL, FromDIP(30));
m_main_sizer->Add(0,0,0, wxTOP, FromDIP(12));
m_main_sizer->Add(label_txt,0, wxLEFT, FromDIP(30));
m_main_sizer->Add(0, 0, 0, wxTOP, FromDIP(5));
m_main_sizer->Add(identical_filament, 0, wxLEFT, FromDIP(30));
m_main_sizer->Add(0,0,0, wxTOP, FromDIP(16));
m_main_sizer->Add(m_scrollview_groups, 1, wxALIGN_CENTER, 0);
m_main_sizer->Add(0,0,0, wxTOP, FromDIP(20));
m_main_sizer->Add(m_button_sizer,0,wxALIGN_CENTER, FromDIP(16));
m_main_sizer->Add(0,0,0, wxTOP, FromDIP(20));
CenterOnParent();
SetSizer(m_main_sizer);
Layout();
Fit();
}
void AmsReplaceMaterialDialog::update_machine_obj(MachineObject* obj)
{
if (obj)
{
m_obj = obj;
if (obj->GetExtderSystem()->GetTotalExtderCount() > 1 && !obj->GetFilaSwitch()->IsReady())
{
// Orca: SwitchBoard has no SetLabels(a,b); set its public left/right labels (left=deputy, right=main).
m_nozzle_btn_panel->leftLabel =
_L(DevPrinterConfigUtil::get_toolhead_display_name(obj->printer_type, DEPUTY_EXTRUDER_ID, ToolHeadComponent::Extruder, ToolHeadNameCase::TitleCase, true));
m_nozzle_btn_panel->rightLabel =
_L(DevPrinterConfigUtil::get_toolhead_display_name(obj->printer_type, MAIN_EXTRUDER_ID, ToolHeadComponent::Extruder, ToolHeadNameCase::TitleCase, true));
m_nozzle_btn_panel->updateState("right");
m_nozzle_btn_panel->Show();
}
else
{
m_nozzle_btn_panel->Hide();
}
update_to_nozzle(MAIN_EXTRUDER_ID);
}
}
AmsRMGroup* AmsReplaceMaterialDialog::create_backup_group(wxString gname, std::map<std::string, wxColour> group_info, wxString material)
{
auto grp = new AmsRMGroup(m_scrollview_groups, group_info, material, gname);
return grp;
}
void AmsReplaceMaterialDialog::paintEvent(wxPaintEvent& evt)
{
wxPaintDC dc(this);
dc.SetPen(StateColor::darkModeColorFor(wxColour("#DBDBDB"))); // Orca: popup border color fixed for dark mode
dc.SetBrush(*wxTRANSPARENT_BRUSH);
dc.DrawRoundedRectangle(0, 0, GetSize().x, GetSize().y, 0);
}
void AmsReplaceMaterialDialog::on_dpi_changed(const wxRect& suggested_rect)
{
}
void AmsReplaceMaterialDialog::update_to_nozzle(int nozzle_id)
{
if (!m_obj)
{
return;
}
if (m_obj->GetExtderSystem()->GetTotalExtderCount() < nozzle_id)
{
return;
}
//update group
int group_index = 0;
m_groups_sizer->Clear(true);
if (m_obj->is_support_filament_backup && m_obj->GetFilaSystem()->IsAutoRefillEnabled())
{
// traverse the amd list
std::unordered_map<int, DevAmsTray*> id2tray;// tray id to tray
try
{
for (const auto& ams_info : m_obj->GetFilaSystem()->GetAmsList())
{
for (auto& tray : ams_info.second->GetTrays()) {
try {
int ams_id = std::stoi(ams_info.first);
int slot_id = std::stoi(tray.first);
// Orca: DevFilaSystem has no GetTrayIdByAmsSlotId wrapper; look the tray id up
// in the (tray_id -> {ams_id, slot_id}) index map directly.
int tray_id = -1;
auto tray_index_map = m_obj->GetFilaSystem()->GetTrayIndexMap();
auto tray_it = std::find_if(tray_index_map.begin(), tray_index_map.end(),
[ams_id, slot_id](const auto& item) { return ams_id == item.second.first && slot_id == item.second.second; });
if (tray_it != tray_index_map.end()) { tray_id = tray_it->first; }
if (tray_id != -1) {
id2tray[tray_id] = tray.second;
}
} catch(...) {
BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << " invalid ams_id:" << ams_info.first << ", slot_id:" << tray.first;
}
}
}
}
catch (...) {}
const auto& extder = m_obj->GetExtderSystem()->GetExtderById(nozzle_id);
if (extder)
{
for (int filam : extder->GetFilamBackup())
{
std::map<std::string, wxColour> group_info;
std::string group_material;
bool is_in_tray = false;
//get color & material
const auto& trayid_group = DevExtder::GetBackupStatus(filam);
for (const auto& elem : trayid_group)
{
if (elem.second)
{
DevAmsTray* cur_tray = id2tray[elem.first];
if (!cur_tray)
continue;
auto tray_name = wxGetApp().transition_tridid(elem.first).ToStdString();
auto it = std::find(m_tray_used.begin(), m_tray_used.end(), tray_name);
if (it != m_tray_used.end())
{
is_in_tray = true;
}
group_info[tray_name] = DevAmsTray::decode_color(cur_tray->color);
group_material = cur_tray->get_display_filament_type();
}
}
if (group_info.size() < 2) /* do not show refill if there is one tray*/
{
continue;
}
if (is_in_tray || m_tray_used.size() <= 0)
{
m_groups_sizer->Add(create_backup_group(wxString::Format("%s%d", _L("Group"), group_index + 1), group_info, group_material), 0, wxALL, FromDIP(10));
group_index++;
}
}
}
}
if (group_index > 0)
{
auto height = 0;
if (group_index > 6)
{
height = FromDIP(550);
}
else
{
height = FromDIP(200) * (std::ceil(group_index / 2.0));
}
m_scrollview_groups->SetMinSize(wxSize(FromDIP(400), height));
m_scrollview_groups->SetMaxSize(wxSize(FromDIP(400), height));
}
else
{
m_scrollview_groups->SetMinSize(wxSize(0, 0));
}
// update text
if (group_index > 0)
{
label_txt->SetLabel(_L("When the current material runs out, the printer would use identical filament to continue printing."));
label_txt->Wrap(FromDIP(380));
identical_filament->Show();
}
else
{
if (!m_obj->is_support_filament_backup)
{
label_txt->SetLabel(_L("The printer does not currently support auto refill."));
}
else if (!m_obj->GetFilaSystem()->IsAutoRefillEnabled())
{
label_txt->SetLabelText(_L("AMS filament backup is not enabled; please enable it in the AMS settings.")); // Orca: kept semicolon (existing translation)
}
else
{
label_txt->SetLabelText(_L("When the current filament runs out, the printer will use identical filament to continue printing.\n"
"*Identical filament: same brand, type and color."));
}
label_txt->Wrap(FromDIP(380));
label_txt->Layout();
identical_filament->Hide();
}
m_groups_sizer->Layout();
m_scrollview_groups->Layout();
Layout();
Fit();
}
AmsRMGroup::AmsRMGroup(wxWindow* parent, std::map<std::string, wxColour> group_info, wxString mname, wxString group_index)
{
#ifdef __WINDOWS__
SetDoubleBuffered(true);
#endif //__WINDOWS__
m_group_info.clear();
m_group_info = group_info;
m_material_name = mname;
m_group_index = group_index;
wxWindow::Create(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize);
SetSize(wxSize(FromDIP(166), FromDIP(166)));
SetMinSize(wxSize(FromDIP(166), FromDIP(166)));
SetMaxSize(wxSize(FromDIP(166), FromDIP(166)));
SetBackgroundColour(*wxWHITE);
backup_current_use_white = ScalableBitmap(this, "backup_current_use1",8);
backup_current_use_black = ScalableBitmap(this, "backup_current_use2", 8);
bitmap_backup_tips_0 = ScalableBitmap(this, "backup_tips_img", 90);
bitmap_editable = ScalableBitmap(this, "ams_editable", 14);
bitmap_bg = ScalableBitmap(this, "back_up_ts_bk", 162);
bitmap_editable_light = ScalableBitmap(this, "ams_editable_light", 14);
Bind(wxEVT_PAINT, &AmsRMGroup::paintEvent, this);
Bind(wxEVT_LEFT_DOWN, &AmsRMGroup::on_mouse_move, this);
wxGetApp().UpdateDarkUI(this);
}
double AmsRMGroup::GetAngle(wxPoint pointA, wxPoint pointB)
{
double deltaX = pointA.x - pointB.x;
double deltaY = pointA.y - pointB.y;
double angle = atan2(deltaY, deltaX);
angle = angle * 180.0 / M_PI;
if (angle < 0)
angle += 360.0;
return angle;
}
void AmsRMGroup::on_mouse_move(wxMouseEvent& evt)
{
wxSize size = GetSize();
auto mouseX = evt.GetPosition().x;
auto mouseY = evt.GetPosition().y;
auto click_angle = 360.0 - GetAngle(wxPoint(mouseX,mouseY), wxPoint(size.x / 2, size.x / 2));
float ev_angle = 360.0 / m_group_info.size();
float startAngle = 0.0;
float endAngle = 0.0;
for (auto iter = m_group_info.rbegin(); iter != m_group_info.rend(); ++iter) {
std::string tray_name = iter->first;
wxColour tray_color = iter->second;
int x = size.x / 2;
int y = size.y / 2;
int radius = size.x / 2;
endAngle += ev_angle;
if (click_angle >= startAngle && click_angle < endAngle) {
//to do
set_index(tray_name);
Refresh();
return;
}
startAngle += ev_angle;
}
evt.Skip();
}
void AmsRMGroup::paintEvent(wxPaintEvent& evt)
{
wxPaintDC dc(this);
render(dc);
}
void AmsRMGroup::render(wxDC& dc)
{
#ifdef __WXMSW__
wxSize size = GetSize();
wxMemoryDC memdc;
wxBitmap bmp(size.x, size.y);
memdc.SelectObject(bmp);
memdc.Blit({ 0, 0 }, size, &dc, { 0, 0 });
{
wxGCDC dc2(memdc);
doRender(dc2);
}
memdc.SelectObject(wxNullBitmap);
dc.DrawBitmap(bmp, 0, 0);
#else
doRender(dc);
#endif
}
wxPoint AmsRMGroup::CalculateEndpoint(const wxPoint& startPoint, int angle, int length)
{
int endX = startPoint.x + length * cos(angle * M_PI / 180);
int endY = startPoint.y + length * sin(angle * M_PI / 180);
return wxPoint(endX, endY);
}
void AmsRMGroup::doRender(wxDC& dc)
{
wxSize size = GetSize();
float center_mask_radius = FromDIP(52);
float selected_radius = FromDIP(53);
float ev_angle = 360.0 / m_group_info.size();
float startAngle = 0.0;
float endAngle = 0.0;
dc.DrawBitmap(bitmap_bg.bmp(), wxPoint((size.x - bitmap_bg.GetBmpSize().x) / 2, (size.y - bitmap_bg.GetBmpSize().y) / 2));
for (auto iter = m_group_info.rbegin(); iter != m_group_info.rend(); ++iter) {
std::string tray_name = iter->first;
wxColour tray_color = iter->second;
dc.SetPen(*wxTRANSPARENT_PEN);
if (tray_color == *wxWHITE) dc.SetPen(wxPen(wxColour("#EEEEEE"), 2));
dc.SetBrush(wxBrush(tray_color));
int x = size.x / 2;
int y = size.y / 2;
int radius;
if (wxGetApp().dark_mode())
radius = size.x / 2 - int(size.x * 0.02);
else
radius = size.x / 2;
endAngle += ev_angle;
//draw body
if (tray_color.Alpha() != 0) {
dc.DrawEllipticArc(x - radius, y - radius, radius * 2, radius * 2, startAngle, endAngle);
if (tray_color == *wxWHITE) dc.DrawEllipticArc(x - center_mask_radius, y - center_mask_radius, center_mask_radius * 2, center_mask_radius * 2, startAngle, endAngle);
}
//draw selected
if (!m_selected_index.empty() && m_selected_index == tray_name) {
dc.SetPen(wxPen(0xCECECE, 2));
dc.SetBrush(*wxTRANSPARENT_BRUSH);
dc.DrawEllipticArc(x - radius, y - radius, radius * 2, radius * 2, startAngle, endAngle);
dc.DrawEllipticArc(x - selected_radius, y - selected_radius,selected_radius * 2, selected_radius * 2, startAngle, endAngle);
}
//...
startAngle += ev_angle;
}
//draw text
startAngle = 0.0;
endAngle = 0.0;
for (auto iter = m_group_info.rbegin(); iter != m_group_info.rend(); ++iter) {
std::string tray_name = iter->first;
wxColour tray_color = iter->second;
int x = size.x / 2;
int y = size.y / 2;
float radius = size.x / 2 - 15.0;
endAngle += ev_angle;
float midAngle = (startAngle + endAngle) / 2;
float x_center = size.x / 2 + radius * cos(midAngle * M_PI / 180.0);
float y_center = size.y / 2 + radius * sin(midAngle * M_PI / 180.0);
//draw tray
dc.SetFont(::Label::Body_12);
auto text_size = dc.GetTextExtent(tray_name);
dc.SetTextForeground(tray_color.GetLuminance() < 0.6 ? *wxWHITE : wxColour("#262E30"));
if (tray_color.Alpha() == 0) { dc.SetTextForeground(wxColour("#262E30")); }
dc.DrawText(tray_name, x_center - text_size.x / 2, size.y - y_center - text_size.y / 2);
//draw split line
dc.SetPen(wxPen(*wxWHITE, 2));
if (tray_color.Alpha() == 0) { dc.SetPen(wxPen(wxColour("#CECECE"), 2)); }
dc.SetBrush(*wxTRANSPARENT_BRUSH);
auto pos_sp_start = CalculateEndpoint(wxPoint(x, y), (360 - startAngle), size.x / 2 - FromDIP(3));
dc.DrawLine(wxPoint(x, y), pos_sp_start);
//draw current
//dc.DrawBitmap(backup_current_use_white.bmp(), x_center - text_size.x / 2 + FromDIP(3), size.y - y_center - text_size.y / 2 + FromDIP(11));
//...
startAngle += ev_angle;
}
//draw center mask
dc.SetPen(*wxTRANSPARENT_PEN);
dc.SetBrush(wxBrush(*wxWHITE));
int x = size.x / 2;
int y = size.y / 2;
dc.DrawEllipticArc(x - center_mask_radius, y - center_mask_radius, center_mask_radius * 2, center_mask_radius * 2, 0, 360);
//draw center icon
dc.DrawBitmap(bitmap_backup_tips_0.bmp(), wxPoint((size.x - bitmap_backup_tips_0.GetBmpSize().x) / 2, (size.y - bitmap_backup_tips_0.GetBmpSize().y) / 2));
//dc.DrawBitmap(bitmap_backup_tips_1.bmp(), wxPoint((size.x - bitmap_backup_tips_1.GetBmpSize().x) / 2, (size.y - bitmap_backup_tips_1.GetBmpSize().y) / 2));
//draw material
dc.SetTextForeground(wxColour("#323A3D"));
dc.SetFont(Label::Head_15);
auto text_size = dc.GetTextExtent(m_material_name);
dc.DrawText(m_material_name, (size.x - text_size.x) / 2,(size.y - text_size.y) / 2 - FromDIP(12));
dc.SetFont(Label::Body_13);
text_size = dc.GetTextExtent(m_group_index);
dc.DrawText(m_group_index, (size.x - text_size.x) / 2, (size.y - text_size.y) / 2 + FromDIP(10));
}
AmsHumidityLevelList::AmsHumidityLevelList(wxWindow* parent)
: wxPanel(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize)
{
#ifdef __WINDOWS__
SetDoubleBuffered(true);
#endif //__WINDOWS__
SetSize(wxSize(FromDIP(680), FromDIP(104)));
SetMinSize(wxSize(FromDIP(680), FromDIP(104)));
SetMaxSize(wxSize(FromDIP(680), FromDIP(104)));
SetBackgroundColour(*wxWHITE);
background_img = ScalableBitmap(this, "humidity_list_background", 104);
for (int i = 5; i > 0; i--) {
hum_level_img_light.push_back(ScalableBitmap(this, ("hum_level" + std::to_string(i) + "_light"), 54));
hum_level_img_dark.push_back(ScalableBitmap(this, ("hum_level" + std::to_string(i) + "_dark"), 54));
}
Bind(wxEVT_PAINT, &AmsHumidityLevelList::paintEvent, this);
wxGetApp().UpdateDarkUI(this);
}
void AmsHumidityLevelList::msw_rescale()
{
background_img.msw_rescale();
for (int i = 0; i < hum_level_img_light.size(); i++)
{
hum_level_img_light[i].msw_rescale();
}
for (int i = 0; i < hum_level_img_dark.size(); i++)
{
hum_level_img_dark[i].msw_rescale();
}
Refresh();
}
void AmsHumidityLevelList::paintEvent(wxPaintEvent& evt)
{
wxPaintDC dc(this);
render(dc);
}
void AmsHumidityLevelList::render(wxDC& dc)
{
#ifdef __WXMSW__
wxSize size = GetSize();
wxMemoryDC memdc;
wxBitmap bmp(size.x, size.y);
memdc.SelectObject(bmp);
memdc.Blit({ 0, 0 }, size, &dc, { 0, 0 });
{
wxGCDC dc2(memdc);
doRender(dc2);
}
memdc.SelectObject(wxNullBitmap);
dc.DrawBitmap(bmp, 0, 0);
#else
doRender(dc);
#endif
}
void AmsHumidityLevelList::doRender(wxDC& dc)
{
dc.DrawBitmap(background_img.bmp(), 0,0);
auto width_center = GetSize().x / 2;
auto left = width_center - FromDIP(27) - FromDIP(46) * 2 - FromDIP(54) * 2;
//dry / wet
dc.SetTextForeground(wxColour("#989898"));
dc.SetFont(::Label::Head_20);
auto font_top = GetSize().y - dc.GetTextExtent(_L("DRY")).GetHeight();
dc.DrawText(_L("DRY"), wxPoint(FromDIP(38), font_top / 2));
dc.DrawText(_L("WET"), wxPoint(( GetSize().x - FromDIP(38) - dc.GetTextExtent(_L("DRY")).GetWidth()), font_top / 2));
//level list
for (int i = 0; i < hum_level_img_light.size(); i++) {
if (wxGetApp().dark_mode()) {
dc.DrawBitmap(hum_level_img_dark[i].bmp(), left, (GetSize().y - FromDIP(54)) / 2);
}
else {
dc.DrawBitmap(hum_level_img_light[i].bmp(), left, (GetSize().y - FromDIP(54)) / 2);
}
left += FromDIP(46) + FromDIP(54);
}
}
DevIconLabel::DevIconLabel(wxWindow* parent, const wxString& icon, const wxString& label)
: wxPanel(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize)
{
CreateGui();
SetIcon(icon);
SetLabel(label);
}
void DevIconLabel::CreateGui()
{
wxSizer* sizer_main = new wxBoxSizer(wxHORIZONTAL);
m_icon = new wxStaticBitmap(this, wxID_ANY, wxNullBitmap);
m_icon->SetBackgroundColour(*wxWHITE);
m_label = new Label(this);
m_label->SetFont(::Label::Body_13);
m_label->SetBackgroundColour(*wxWHITE);
sizer_main->Add(m_icon, 0, wxALIGN_CENTER_VERTICAL, 0);
sizer_main->Add(m_label, 0, wxALIGN_CENTER_VERTICAL | wxLEFT, FromDIP(8));
SetSizer(sizer_main);
Layout();
Fit();
}
void DevIconLabel::SetLabel(const wxString& label)
{
m_label->SetLabel(label);
}
void DevIconLabel::SetIcon(const wxString& icon)
{
if (m_icon_str != icon) {
m_icon_str = icon;
m_icon->SetBitmap(create_scaled_bitmap(icon.ToStdString(), this, 20));
Refresh();
}
}
void DevIconLabel::SetAllBackgroundColor(const wxColour& color)
{
SetBackgroundColour(color);
m_icon->SetBackgroundColour(color);
m_label->SetBackgroundColour(color);
}
void Slic3r::GUI::DevIconLabel::Rescale()
{
m_icon->SetBitmap(create_scaled_bitmap(m_icon_str.ToStdString(), this, 20));
Refresh();
}
}} // namespace Slic3r::GUI
Reference in New Issue View Git Blame Copy Permalink