3D-printing/OrcaSlicer
1
0
Fork 0
mirror of https://github.com/SoftFever/OrcaSlicer.git synced 2026-02-15 17:09:43 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions 7

Rename AMSItem to AMSPreview

Browse source
This commit is contained in:
Noisyfox 2025-05-21 10:18:33 +08:00
parent 9c8736f416
commit d654408bed
6 changed files with 299 additions and 319 deletions
Download patch file Download diff file Expand all files Collapse all files

19
src/slic3r/GUI/CalibrationWizardPresetPage.cpp
View file

@ -614,12 +614,12 @@ void CalibrationPresetPage::create_filament_list_panel(wxWindow* parent)
auto ams_items_sizer = new wxBoxSizer(wxHORIZONTAL);
for (int i = 0; i < 4; i++) {
AMSinfo temp_info = AMSinfo{ std::to_string(i), std::vector<Caninfo>{} };
auto amsitem = new AMSItem(m_multi_ams_panel, wxID_ANY, temp_info);
auto amsitem = new AMSPreview(m_multi_ams_panel, wxID_ANY, temp_info);
amsitem->Bind(wxEVT_LEFT_DOWN, [this, amsitem](wxMouseEvent& e) {
on_switch_ams(amsitem->m_amsinfo.ams_id);
on_switch_ams(amsitem->get_ams_id());
e.Skip();
});
m_ams_item_list.push_back(amsitem);
m_ams_preview_list.push_back(amsitem);
ams_items_sizer->Add(amsitem, 0, wxALIGN_CENTER | wxRIGHT, FromDIP(6));
}
multi_ams_sizer->Add(ams_items_sizer, 0);
@ -896,12 +896,11 @@ void CalibrationPresetPage::on_select_tray(wxCommandEvent& event)
void CalibrationPresetPage::on_switch_ams(std::string ams_id)
{
for (auto i = 0; i < m_ams_item_list.size(); i++) {
AMSItem* item = m_ams_item_list[i];
if (item->m_amsinfo.ams_id == ams_id) {
for (auto i = 0; i < m_ams_preview_list.size(); i++) {
AMSPreview *item = m_ams_preview_list[i];
if (item->get_ams_id() == ams_id) {
item->OnSelected();
}
else {
} else {
item->UnSelected();
}
}
@ -1616,8 +1615,8 @@ void CalibrationPresetPage::sync_ams_info(MachineObject* obj)
}
}
for (auto i = 0; i < m_ams_item_list.size(); i++) {
AMSItem* item = m_ams_item_list[i];
for (auto i = 0; i < m_ams_preview_list.size(); i++) {
AMSPreview* item = m_ams_preview_list[i];
if (ams_info.size() > 1) {
if (i < ams_info.size()) {
item->Update(ams_info[i]);

4
src/slic3r/GUI/CalibrationWizardPresetPage.hpp
View file

@ -284,8 +284,8 @@ protected:
FilamentComboBoxList m_filament_comboBox_list;
FilamentComboBox* m_virtual_tray_comboBox;
std::vector<AMSItem*> m_ams_item_list;
std::vector<AMSPreview*> m_ams_preview_list;
// for update filament combobox, key : tray_id
std::map<int, DynamicPrintConfig> filament_ams_list;

121
src/slic3r/GUI/Widgets/AMSControl.cpp
View file

@ -19,7 +19,6 @@ namespace Slic3r { namespace GUI {
/*************************************************
Description:AMSControl
**************************************************/
// WX_DEFINE_OBJARRAY(AmsItemsHash);
AMSControl::AMSControl(wxWindow *parent, wxWindowID id, const wxPoint &pos, const wxSize &size)
: wxSimplebook(parent, wxID_ANY, pos, size)
, m_Humidity_tip_popup(AmsHumidityTipPopup(this))
@ -34,28 +33,28 @@ AMSControl::AMSControl(wxWindow *parent, wxWindowID id, const wxPoint &pos, cons
m_amswin->SetBackgroundColour(*wxWHITE);
// top - ams tag
m_simplebook_amsitems = new wxSimplebook(m_amswin, wxID_ANY);
m_simplebook_amsitems->SetSize(wxSize(-1, AMS_CAN_ITEM_HEIGHT_SIZE));
m_simplebook_amsitems->SetMinSize(wxSize(-1, AMS_CAN_ITEM_HEIGHT_SIZE));
auto m_sizer_amsitems = new wxBoxSizer(wxHORIZONTAL);
m_simplebook_amsitems->SetSizer(m_sizer_amsitems);
m_simplebook_amsitems->Layout();
m_sizer_amsitems->Fit(m_simplebook_amsitems);
m_simplebook_amsprvs = new wxSimplebook(m_amswin, wxID_ANY);
m_simplebook_amsprvs->SetSize(wxSize(-1, AMS_CAN_ITEM_HEIGHT_SIZE));
m_simplebook_amsprvs->SetMinSize(wxSize(-1, AMS_CAN_ITEM_HEIGHT_SIZE));
auto m_sizer_amspreviews = new wxBoxSizer(wxHORIZONTAL);
m_simplebook_amsprvs->SetSizer(m_sizer_amspreviews);
m_simplebook_amsprvs->Layout();
m_sizer_amspreviews->Fit(m_simplebook_amsprvs);
m_panel_top = new wxPanel(m_simplebook_amsitems, wxID_ANY, wxDefaultPosition, wxSize(-1, AMS_CAN_ITEM_HEIGHT_SIZE));
m_sizer_top = new wxBoxSizer(wxHORIZONTAL);
m_panel_top->SetSizer(m_sizer_top);
m_panel_top->Layout();
m_sizer_top->Fit(m_panel_top);
m_panel_prv = new wxPanel(m_simplebook_amsprvs, wxID_ANY, wxDefaultPosition, wxSize(-1, AMS_CAN_ITEM_HEIGHT_SIZE));
m_sizer_prv = new wxBoxSizer(wxHORIZONTAL);
m_panel_prv->SetSizer(m_sizer_prv);
m_panel_prv->Layout();
m_sizer_prv->Fit(m_panel_prv);
auto m_panel_top_empty = new wxPanel(m_simplebook_amsitems, wxID_ANY, wxDefaultPosition, wxSize(-1, AMS_CAN_ITEM_HEIGHT_SIZE));
auto m_panel_top_empty = new wxPanel(m_simplebook_amsprvs, wxID_ANY, wxDefaultPosition, wxSize(-1, AMS_CAN_ITEM_HEIGHT_SIZE));
auto m_sizer_top_empty = new wxBoxSizer(wxHORIZONTAL);
m_panel_top_empty->SetSizer(m_sizer_top_empty);
m_panel_top_empty->Layout();
m_sizer_top_empty->Fit(m_panel_top_empty);
m_simplebook_amsitems->AddPage(m_panel_top_empty, wxEmptyString, false);
m_simplebook_amsitems->AddPage(m_panel_top, wxEmptyString, false);
m_simplebook_amsprvs->AddPage(m_panel_top_empty, wxEmptyString, false);
m_simplebook_amsprvs->AddPage(m_panel_prv, wxEmptyString, false);
wxBoxSizer *m_sizer_bottom = new wxBoxSizer(wxHORIZONTAL);
@ -456,7 +455,7 @@ AMSControl::AMSControl(wxWindow *parent, wxWindowID id, const wxPoint &pos, cons
m_sizer_bottom->Add(0, 0, 0, wxLEFT, FromDIP(15));
m_sizer_bottom->Add(m_sizer_right, 0, wxEXPAND, FromDIP(0));
m_sizer_body->Add(m_simplebook_amsitems, 0, wxEXPAND, 0);
m_sizer_body->Add(m_simplebook_amsprvs, 0, wxEXPAND, 0);
m_sizer_body->Add(0, 0, 1, wxEXPAND | wxTOP, FromDIP(18));
m_sizer_body->Add(m_sizer_bottom, 0, wxEXPAND | wxLEFT, FromDIP(6));
@ -657,9 +656,9 @@ void AMSControl::EnterNoneAMSMode()
{
m_vams_lib->m_ams_model = m_ext_model;
if(m_is_none_ams_mode == AMSModel::EXT_AMS) return;
m_panel_top->Hide();
m_simplebook_amsitems->Hide();
m_simplebook_amsitems->SetSelection(0);
m_panel_prv->Hide();
m_simplebook_amsprvs->Hide();
m_simplebook_amsprvs->SetSelection(0);
m_simplebook_ams->SetSelection(0);
m_extruder->no_ams_mode(true);
@ -679,9 +678,9 @@ void AMSControl::EnterGenericAMSMode()
{
m_vams_lib->m_ams_model = m_ext_model;
if(m_is_none_ams_mode == AMSModel::GENERIC_AMS) return;
m_panel_top->Show();
m_simplebook_amsitems->Show();
m_simplebook_amsitems->SetSelection(1);
m_panel_prv->Show();
m_simplebook_amsprvs->Show();
m_simplebook_amsprvs->SetSelection(1);
m_vams_lib->m_ams_model = AMSModel::GENERIC_AMS;
m_ams_tip->SetLabel(_L("AMS"));
@ -708,9 +707,9 @@ void AMSControl::EnterExtraAMSMode()
{
m_vams_lib->m_ams_model = m_ext_model;
if(m_is_none_ams_mode == AMSModel::AMS_LITE) return;
m_panel_top->Hide();
m_simplebook_amsitems->Show();
m_simplebook_amsitems->SetSelection(1);
m_panel_prv->Hide();
m_simplebook_amsprvs->Show();
m_simplebook_amsprvs->SetSelection(1);
m_vams_lib->m_ams_model = AMSModel::AMS_LITE;
@ -891,13 +890,13 @@ void AMSControl::CreateAms()
std::vector<AMSinfo>::iterator it;
Freeze();
for (it = ams_info.begin(); it != ams_info.end(); it++) {
AddAmsItems(*it);
AddAmsPreview(*it);
AddAms(*it);
AddExtraAms(*it);
m_ams_info.push_back(*it);
}
m_sizer_top->Layout();
m_sizer_prv->Layout();
Thaw();
}
@ -1021,27 +1020,29 @@ void AMSControl::UpdateAms(std::vector<AMSinfo> info, bool is_reset)
}
if (info.size() > 1) {
m_simplebook_amsitems->Show();
m_simplebook_amsprvs->Show();
m_amswin->Layout();
m_amswin->Fit();
SetSize(m_amswin->GetSize());
SetMinSize(m_amswin->GetSize());
} else {
m_simplebook_amsitems->Hide();
m_simplebook_amsprvs->Hide();
m_amswin->Layout();
m_amswin->Fit();
SetSize(m_amswin->GetSize());
SetMinSize(m_amswin->GetSize());
}
for (auto i = 0; i < m_ams_item_list.GetCount(); i++) {
AmsItems *item = m_ams_item_list[i];
size_t i = 0;
for (auto prv_it : m_ams_preview_list) {
AMSPreview* prv = prv_it.second;
if (i < info.size() && info.size() > 1) {
item->amsItem->Update(m_ams_info[i]);
item->amsItem->Open();
prv->Update(m_ams_info[i]);
prv->Open();
} else {
item->amsItem->Close();
prv->Close();
}
i++;
}
// update cans
@ -1088,20 +1089,16 @@ void AMSControl::UpdateAms(std::vector<AMSinfo> info, bool is_reset)
}
}
void AMSControl::AddAmsItems(AMSinfo info)
void AMSControl::AddAmsPreview(AMSinfo info)
{
auto amsitem = new AMSItem(m_panel_top, wxID_ANY, info);
amsitem->Bind(wxEVT_LEFT_DOWN, [this, amsitem](wxMouseEvent& e) {
SwitchAms(amsitem->m_amsinfo.ams_id);
auto ams_prv = new AMSPreview(m_panel_prv, wxID_ANY, info);
m_sizer_prv->Add(ams_prv, 0, wxALIGN_CENTER | wxRIGHT, 6);
ams_prv->Bind(wxEVT_LEFT_DOWN, [this, ams_prv](wxMouseEvent& e) {
SwitchAms(ams_prv->get_ams_id());
e.Skip();
});
AmsItems* item = new AmsItems();
item->amsIndex = info.ams_id;
item->amsItem = amsitem;
m_ams_item_list.Add(item);
m_sizer_top->Add(amsitem, 0, wxALIGN_CENTER | wxRIGHT, 6);
m_ams_preview_list[info.ams_id] = ams_prv;
}
void AMSControl::AddAms(AMSinfo info)
@ -1141,24 +1138,12 @@ void AMSControl::SwitchAms(std::string ams_id)
}
}
for (auto i = 0; i < m_ams_item_list.GetCount(); i++) {
AmsItems *item = m_ams_item_list[i];
if (item->amsItem->m_amsinfo.ams_id == m_current_show_ams) {
item->amsItem->OnSelected();
for (auto prv_it : m_ams_preview_list) {
AMSPreview* prv = prv_it.second;
if (prv->get_ams_id() == m_current_show_ams) {
prv->OnSelected();
m_current_select = ams_id;
//bool ready_selected = false;
//for (auto i = 0; i < m_ams_cans_list.GetCount(); i++) {
// AmsCansWindow* ams = m_ams_cans_list[i];
// if (ams->amsCans->m_info.ams_id == ams_id) {
// //ams->amsCans->SetDefSelectCan();
// //m_vams_lib->OnSelected();
// if () {
// }
// }
//}
bool ready_selected = false;
for (auto i = 0; i < m_ams_cans_list.GetCount(); i++) {
AmsCansWindow* ams = m_ams_cans_list[i];
@ -1181,10 +1166,10 @@ void AMSControl::SwitchAms(std::string ams_id)
}
} else {
item->amsItem->UnSelected();
prv->UnSelected();
}
m_sizer_top->Layout();
m_panel_top->Fit();
m_sizer_prv->Layout();
m_panel_prv->Fit();
}
for (auto i = 0; i < m_ams_cans_list.GetCount(); i++) {
@ -1309,9 +1294,9 @@ void AMSControl::ShowFilamentTip(bool hasams)
bool AMSControl::Enable(bool enable)
{
for (auto i = 0; i < m_ams_item_list.GetCount(); i++) {
AmsItems *item = m_ams_item_list[i];
item->amsItem->Enable(enable);
for (auto prv_it : m_ams_preview_list) {
AMSPreview* prv = prv_it.second;
prv->Enable(enable);
}
for (auto i = 0; i < m_ams_cans_list.GetCount(); i++) {

12
src/slic3r/GUI/Widgets/AMSControl.hpp
View file

@ -32,8 +32,8 @@ protected:
std::string m_current_ams;
std::string m_current_show_ams;
std::map<std::string, int> m_ams_selection;
AmsItemsHash m_ams_item_list;
std::map<std::string, AMSPreview*> m_ams_preview_list;
std::vector<AMSinfo> m_ams_info;
AmsCansHash m_ams_cans_list;
@ -46,7 +46,7 @@ protected:
wxSimplebook *m_simplebook_right = {nullptr};
wxSimplebook *m_simplebook_calibration = {nullptr};
wxSimplebook *m_simplebook_amsitems = {nullptr};
wxSimplebook *m_simplebook_amsprvs = {nullptr};
wxSimplebook *m_simplebook_ams = {nullptr};
wxSimplebook *m_simplebook_generic_cans= {nullptr};
@ -58,7 +58,7 @@ protected:
Label *m_tip_load_info = {nullptr};
wxStaticText *m_text_calibration_percent = {nullptr};
wxWindow * m_none_ams_panel = {nullptr};
wxWindow * m_panel_top = {nullptr};
wxWindow* m_panel_prv = {nullptr};
wxWindow * m_amswin = {nullptr};
wxBoxSizer* m_vams_sizer = {nullptr};
wxBoxSizer* m_sizer_vams_tips = {nullptr};
@ -73,7 +73,7 @@ protected:
AMSVirtualRoad* m_vams_extra_road = {nullptr};
StaticBox * m_panel_can = {nullptr};
wxBoxSizer *m_sizer_top = {nullptr};
wxBoxSizer* m_sizer_prv = {nullptr};
wxBoxSizer *m_sizer_cans = {nullptr};
wxBoxSizer *m_sizer_right_tip = {nullptr};
wxBoxSizer* m_sizer_ams_tips = {nullptr};
@ -135,7 +135,7 @@ public:
void CreateAms();
void UpdateAms(std::vector<AMSinfo> info, bool is_reset = true);
void AddAms(AMSinfo info);
void AddAmsItems(AMSinfo info);
void AddAmsPreview(AMSinfo info);
void AddExtraAms(AMSinfo info);
void SetExtruder(bool on_off, bool is_vams, std::string ams_now, wxColour col);
void SetAmsStep(std::string ams_id, std::string canid, AMSPassRoadType type, AMSPassRoadSTEP step);

373
src/slic3r/GUI/Widgets/AMSItem.cpp
View file

@ -2171,6 +2171,193 @@ void AmsCans::show_sn_value(bool show)
}
}
/*************************************************
Description:AMSPreview
**************************************************/
AMSPreview::AMSPreview() {}
AMSPreview::AMSPreview(wxWindow *parent, wxWindowID id, AMSinfo amsinfo, const wxSize cube_size, const wxPoint &pos, const wxSize &size) : AMSPreview()
{
m_amsinfo = amsinfo;
m_cube_size = cube_size;
create(parent, id, pos, AMS_ITEM_SIZE);
Bind(wxEVT_PAINT, &AMSPreview::paintEvent, this);
Bind(wxEVT_ENTER_WINDOW, &AMSPreview::OnEnterWindow, this);
Bind(wxEVT_LEAVE_WINDOW, &AMSPreview::OnLeaveWindow, this);
}
void AMSPreview::Open()
{
m_open = true;
Show();
}
void AMSPreview::Close()
{
m_open = false;
Hide();
}
void AMSPreview::Update(AMSinfo amsinfo)
{
m_amsinfo = amsinfo;
}
void AMSPreview::create(wxWindow *parent, wxWindowID id, const wxPoint &pos, const wxSize &size)
{
m_ts_bitmap_cube = new ScalableBitmap(this, "ts_bitmap_cube", 14);
wxWindow::Create(parent, id, pos, size);
SetMinSize(AMS_ITEM_SIZE);
SetMaxSize(AMS_ITEM_SIZE);
SetBackgroundColour(AMS_CONTROL_WHITE_COLOUR);
Refresh();
}
void AMSPreview::OnEnterWindow(wxMouseEvent &evt)
{
// m_hover = true;
// Refresh();
}
void AMSPreview::OnLeaveWindow(wxMouseEvent &evt)
{
// m_hover = false;
// Refresh();
}
void AMSPreview::OnSelected()
{
if (!wxWindow::IsEnabled()) { return; }
m_selected = true;
Refresh();
}
void AMSPreview::UnSelected()
{
m_selected = false;
Refresh();
}
bool AMSPreview::Enable(bool enable) { return wxWindow::Enable(enable); }
void AMSPreview::paintEvent(wxPaintEvent &evt)
{
wxPaintDC dc(this);
render(dc);
}
void AMSPreview::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 AMSPreview::doRender(wxDC &dc)
{
wxSize size = GetSize();
dc.SetPen(wxPen(StateColor::darkModeColorFor(m_background_colour)));
dc.SetBrush(wxBrush(StateColor::darkModeColorFor(m_background_colour)));
dc.DrawRoundedRectangle(0, 0, size.x, size.y, 3);
auto left = m_padding;
for (std::vector<Caninfo>::iterator iter = m_amsinfo.cans.begin(); iter != m_amsinfo.cans.end(); iter++) {
dc.SetPen(wxPen(*wxTRANSPARENT_PEN));
if (wxWindow::IsEnabled()) {
wxColour color = iter->material_colour;
change_the_opacity(color);
dc.SetBrush(wxBrush(color));
} else {
dc.SetBrush(AMS_CONTROL_DISABLE_COLOUR);
}
if (iter->material_cols.size() > 1) {
int fleft = left;
float total_width = AMS_ITEM_CUBE_SIZE.x;
int gwidth = std::round(total_width / (iter->material_cols.size() - 1));
if (iter->ctype == 0) {
for (int i = 0; i < iter->material_cols.size() - 1; i++) {
if ((fleft + gwidth) > (AMS_ITEM_CUBE_SIZE.x)) {
gwidth = (fleft + AMS_ITEM_CUBE_SIZE.x) - fleft;
}
auto rect = wxRect(fleft, (size.y - AMS_ITEM_CUBE_SIZE.y) / 2, gwidth, AMS_ITEM_CUBE_SIZE.y);
dc.GradientFillLinear(rect, iter->material_cols[i], iter->material_cols[i + 1], wxEAST);
fleft += gwidth;
}
} else {
int cols_size = iter->material_cols.size();
for (int i = 0; i < cols_size; i++) {
dc.SetBrush(wxBrush(iter->material_cols[i]));
float x = left + total_width * i / cols_size;
dc.DrawRoundedRectangle(x, (size.y - AMS_ITEM_CUBE_SIZE.y) / 2, total_width / cols_size, AMS_ITEM_CUBE_SIZE.y , 0);
}
}
dc.SetPen(wxPen(StateColor::darkModeColorFor(m_background_colour)));
dc.SetBrush(*wxTRANSPARENT_BRUSH);
dc.DrawRoundedRectangle(left - 1, (size.y - AMS_ITEM_CUBE_SIZE.y) / 2 - 1, AMS_ITEM_CUBE_SIZE.x + 2, AMS_ITEM_CUBE_SIZE.y + 2, 2);
}else {
if (iter->material_colour.Alpha() == 0) {
dc.DrawBitmap(m_ts_bitmap_cube->bmp(),left,(size.y - AMS_ITEM_CUBE_SIZE.y) / 2);
}
else {
wxRect rect(left, (size.y - AMS_ITEM_CUBE_SIZE.y) / 2, AMS_ITEM_CUBE_SIZE.x, AMS_ITEM_CUBE_SIZE.y);
if(iter->material_state==AMSCanType::AMS_CAN_TYPE_EMPTY){
dc.SetPen(wxPen(wxColor(0, 0, 0)));
dc.DrawRoundedRectangle(rect, 2);
dc.DrawLine(rect.GetRight()-1, rect.GetTop()+1, rect.GetLeft()+1, rect.GetBottom()-1);
}
else {
dc.DrawRoundedRectangle(rect, 2);
}
}
}
left += AMS_ITEM_CUBE_SIZE.x;
left += m_space;
}
auto border_colour = AMS_CONTROL_BRAND_COLOUR;
if (!wxWindow::IsEnabled()) { border_colour = AMS_CONTROL_DISABLE_COLOUR; }
if (m_hover) {
dc.SetPen(wxPen(border_colour, 2));
dc.SetBrush(wxBrush(*wxTRANSPARENT_BRUSH));
dc.DrawRoundedRectangle(1, 1, size.x - 1, size.y - 1, 3);
}
if (m_selected) {
dc.SetPen(wxPen(border_colour, 2));
dc.SetBrush(wxBrush(*wxTRANSPARENT_BRUSH));
dc.DrawRoundedRectangle(1, 1, size.x-1, size.y-1, 3);
}
}
void AMSPreview::DoSetSize(int x, int y, int width, int height, int sizeFlags /*= wxSIZE_AUTO*/) { wxWindow::DoSetSize(x, y, width, height, sizeFlags); }
/*************************************************
Description:AMSHumidity
**************************************************/
@ -2387,190 +2574,4 @@ void AMSHumidity::msw_rescale() {
Refresh();
}
/*************************************************
Description:AMSItem
**************************************************/
AMSItem::AMSItem() {}
AMSItem::AMSItem(wxWindow *parent, wxWindowID id, AMSinfo amsinfo, const wxSize cube_size, const wxPoint &pos, const wxSize &size) : AMSItem()
{
m_amsinfo = amsinfo;
m_cube_size = cube_size;
create(parent, id, pos, AMS_ITEM_SIZE);
Bind(wxEVT_PAINT, &AMSItem::paintEvent, this);
Bind(wxEVT_ENTER_WINDOW, &AMSItem::OnEnterWindow, this);
Bind(wxEVT_LEAVE_WINDOW, &AMSItem::OnLeaveWindow, this);
}
void AMSItem::Open()
{
m_open = true;
Show();
}
void AMSItem::Close()
{
m_open = false;
Hide();
}
void AMSItem::Update(AMSinfo amsinfo)
{
m_amsinfo = amsinfo;
}
void AMSItem::create(wxWindow *parent, wxWindowID id, const wxPoint &pos, const wxSize &size)
{
m_ts_bitmap_cube = new ScalableBitmap(this, "ts_bitmap_cube", 14);
wxWindow::Create(parent, id, pos, size);
SetMinSize(AMS_ITEM_SIZE);
SetMaxSize(AMS_ITEM_SIZE);
SetBackgroundColour(AMS_CONTROL_WHITE_COLOUR);
Refresh();
}
void AMSItem::OnEnterWindow(wxMouseEvent &evt)
{
// m_hover = true;
// Refresh();
}
void AMSItem::OnLeaveWindow(wxMouseEvent &evt)
{
// m_hover = false;
// Refresh();
}
void AMSItem::OnSelected()
{
if (!wxWindow::IsEnabled()) { return; }
m_selected = true;
Refresh();
}
void AMSItem::UnSelected()
{
m_selected = false;
Refresh();
}
bool AMSItem::Enable(bool enable) { return wxWindow::Enable(enable); }
void AMSItem::paintEvent(wxPaintEvent &evt)
{
wxPaintDC dc(this);
render(dc);
}
void AMSItem::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 AMSItem::doRender(wxDC &dc)
{
wxSize size = GetSize();
dc.SetPen(wxPen(StateColor::darkModeColorFor(m_background_colour)));
dc.SetBrush(wxBrush(StateColor::darkModeColorFor(m_background_colour)));
dc.DrawRoundedRectangle(0, 0, size.x, size.y, 3);
auto left = m_padding;
for (std::vector<Caninfo>::iterator iter = m_amsinfo.cans.begin(); iter != m_amsinfo.cans.end(); iter++) {
dc.SetPen(wxPen(*wxTRANSPARENT_PEN));
if (wxWindow::IsEnabled()) {
wxColour color = iter->material_colour;
change_the_opacity(color);
dc.SetBrush(wxBrush(color));
} else {
dc.SetBrush(AMS_CONTROL_DISABLE_COLOUR);
}
if (iter->material_cols.size() > 1) {
int fleft = left;
float total_width = AMS_ITEM_CUBE_SIZE.x;
int gwidth = std::round(total_width / (iter->material_cols.size() - 1));
if (iter->ctype == 0) {
for (int i = 0; i < iter->material_cols.size() - 1; i++) {
if ((fleft + gwidth) > (AMS_ITEM_CUBE_SIZE.x)) {
gwidth = (fleft + AMS_ITEM_CUBE_SIZE.x) - fleft;
}
auto rect = wxRect(fleft, (size.y - AMS_ITEM_CUBE_SIZE.y) / 2, gwidth, AMS_ITEM_CUBE_SIZE.y);
dc.GradientFillLinear(rect, iter->material_cols[i], iter->material_cols[i + 1], wxEAST);
fleft += gwidth;
}
} else {
int cols_size = iter->material_cols.size();
for (int i = 0; i < cols_size; i++) {
dc.SetBrush(wxBrush(iter->material_cols[i]));
float x = left + total_width * i / cols_size;
dc.DrawRoundedRectangle(x, (size.y - AMS_ITEM_CUBE_SIZE.y) / 2, total_width / cols_size, AMS_ITEM_CUBE_SIZE.y , 0);
}
}
dc.SetPen(wxPen(StateColor::darkModeColorFor(m_background_colour)));
dc.SetBrush(*wxTRANSPARENT_BRUSH);
dc.DrawRoundedRectangle(left - 1, (size.y - AMS_ITEM_CUBE_SIZE.y) / 2 - 1, AMS_ITEM_CUBE_SIZE.x + 2, AMS_ITEM_CUBE_SIZE.y + 2, 2);
}else {
if (iter->material_colour.Alpha() == 0) {
dc.DrawBitmap(m_ts_bitmap_cube->bmp(),left,(size.y - AMS_ITEM_CUBE_SIZE.y) / 2);
}
else {
wxRect rect(left, (size.y - AMS_ITEM_CUBE_SIZE.y) / 2, AMS_ITEM_CUBE_SIZE.x, AMS_ITEM_CUBE_SIZE.y);
if(iter->material_state==AMSCanType::AMS_CAN_TYPE_EMPTY){
dc.SetPen(wxPen(wxColor(0, 0, 0)));
dc.DrawRoundedRectangle(rect, 2);
dc.DrawLine(rect.GetRight()-1, rect.GetTop()+1, rect.GetLeft()+1, rect.GetBottom()-1);
}
else {
dc.DrawRoundedRectangle(rect, 2);
}
}
}
left += AMS_ITEM_CUBE_SIZE.x;
left += m_space;
}
auto border_colour = AMS_CONTROL_BRAND_COLOUR;
if (!wxWindow::IsEnabled()) { border_colour = AMS_CONTROL_DISABLE_COLOUR; }
if (m_hover) {
dc.SetPen(wxPen(border_colour, 2));
dc.SetBrush(wxBrush(*wxTRANSPARENT_BRUSH));
dc.DrawRoundedRectangle(1, 1, size.x - 1, size.y - 1, 3);
}
if (m_selected) {
dc.SetPen(wxPen(border_colour, 2));
dc.SetBrush(wxBrush(*wxTRANSPARENT_BRUSH));
dc.DrawRoundedRectangle(1, 1, size.x-1, size.y-1, 3);
}
}
void AMSItem::DoSetSize(int x, int y, int width, int height, int sizeFlags /*= wxSIZE_AUTO*/) { wxWindow::DoSetSize(x, y, width, height, sizeFlags); }
}} // namespace Slic3r::GUI

89
src/slic3r/GUI/Widgets/AMSItem.hpp
View file

@ -465,6 +465,48 @@ public:
void doRender(wxDC& dc);
};
/*************************************************
Description:AMSPreview
**************************************************/
class AMSPreview : public wxWindow
{
public:
AMSPreview();
AMSPreview(wxWindow *parent, wxWindowID id, AMSinfo amsinfo, const wxSize cube_size = wxSize(14, 14), const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize);
bool m_open = {false};
void Open();
void Close();
void Update(AMSinfo amsinfo);
void create(wxWindow *parent, wxWindowID id, const wxPoint &pos, const wxSize &size);
void OnEnterWindow(wxMouseEvent &evt);
void OnLeaveWindow(wxMouseEvent &evt);
void OnSelected();
void UnSelected();
virtual bool Enable(bool enable = true);
std::string get_ams_id() const { return m_amsinfo.ams_id; };
protected:
AMSinfo m_amsinfo;
wxSize m_cube_size;
wxColour m_background_colour = {AMS_CONTROL_DEF_LIB_BK_COLOUR};
int m_padding = {7};
int m_space = {5};
bool m_hover = {false};
bool m_selected = {false};
ScalableBitmap* m_ts_bitmap_cube;
void paintEvent(wxPaintEvent &evt);
void render(wxDC &dc);
void doRender(wxDC &dc);
virtual void DoSetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO);
};
/*************************************************
Description:AMSHumidity
**************************************************/
@ -501,45 +543,6 @@ private:
void update_size();
};
/*************************************************
Description:AMSItem
**************************************************/
class AMSItem : public wxWindow
{
public:
AMSItem();
AMSItem(wxWindow *parent, wxWindowID id, AMSinfo amsinfo, const wxSize cube_size = wxSize(14, 14), const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize);
bool m_open = {false};
void Open();
void Close();
void Update(AMSinfo amsinfo);
void create(wxWindow *parent, wxWindowID id, const wxPoint &pos, const wxSize &size);
void OnEnterWindow(wxMouseEvent &evt);
void OnLeaveWindow(wxMouseEvent &evt);
void OnSelected();
void UnSelected();
virtual bool Enable(bool enable = true);
AMSinfo m_amsinfo;
protected:
wxSize m_cube_size;
wxColour m_background_colour = {AMS_CONTROL_DEF_LIB_BK_COLOUR};
int m_padding = {7};
int m_space = {5};
bool m_hover = {false};
bool m_selected = {false};
ScalableBitmap* m_ts_bitmap_cube;
void paintEvent(wxPaintEvent &evt);
void render(wxDC &dc);
void doRender(wxDC &dc);
virtual void DoSetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO);
};
/*************************************************
Description:AmsCans
**************************************************/
@ -638,13 +641,6 @@ public:
}
};
class AmsItems
{
public:
wxString amsIndex;
AMSItem *amsItem;
};
class AMSextruders
{
public:
@ -653,7 +649,6 @@ public:
};
WX_DEFINE_ARRAY(AmsCansWindow *, AmsCansHash);
WX_DEFINE_ARRAY(AmsItems *, AmsItemsHash);
WX_DEFINE_ARRAY(AMSextruders *, AMSextrudersHash);