3584 lines
124 KiB
C++
3584 lines
124 KiB
C++
#include "AMSItem.hpp"
|
|
#include "Label.hpp"
|
|
#include "../BitmapCache.hpp"
|
|
#include "../I18N.hpp"
|
|
#include "../GUI_App.hpp"
|
|
|
|
#include <wx/simplebook.h>
|
|
#include <wx/dcgraph.h>
|
|
|
|
#include <boost/log/trivial.hpp>
|
|
|
|
#include "CalibUtils.hpp"
|
|
|
|
|
|
|
|
namespace Slic3r { namespace GUI {
|
|
|
|
static const wxColour AMS_TRAY_DEFAULT_COL = wxColour(255, 255, 255);
|
|
wxDEFINE_EVENT(EVT_AMS_EXTRUSION_CALI, wxCommandEvent);
|
|
wxDEFINE_EVENT(EVT_AMS_LOAD, SimpleEvent);
|
|
wxDEFINE_EVENT(EVT_AMS_UNLOAD, SimpleEvent);
|
|
wxDEFINE_EVENT(EVT_AMS_SETTINGS, SimpleEvent);
|
|
wxDEFINE_EVENT(EVT_AMS_FILAMENT_BACKUP, SimpleEvent);
|
|
wxDEFINE_EVENT(EVT_AMS_REFRESH_RFID, wxCommandEvent);
|
|
wxDEFINE_EVENT(EVT_AMS_ON_SELECTED, wxCommandEvent);
|
|
wxDEFINE_EVENT(EVT_AMS_ON_FILAMENT_EDIT, wxCommandEvent);
|
|
wxDEFINE_EVENT(EVT_VAMS_ON_FILAMENT_EDIT, wxCommandEvent);
|
|
wxDEFINE_EVENT(EVT_AMS_CLIBRATION_AGAIN, wxCommandEvent);
|
|
wxDEFINE_EVENT(EVT_AMS_CLIBRATION_CANCEL, wxCommandEvent);
|
|
wxDEFINE_EVENT(EVT_AMS_GUIDE_WIKI, wxCommandEvent);
|
|
wxDEFINE_EVENT(EVT_AMS_RETRY, wxCommandEvent);
|
|
wxDEFINE_EVENT(EVT_AMS_SHOW_HUMIDITY_TIPS, wxCommandEvent);
|
|
wxDEFINE_EVENT(EVT_AMS_UNSELETED_VAMS, wxCommandEvent);
|
|
wxDEFINE_EVENT(EVT_CLEAR_SPEED_CONTROL, wxCommandEvent);
|
|
wxDEFINE_EVENT(EVT_AMS_SWITCH, SimpleEvent);
|
|
|
|
|
|
#define AMS_CANS_SIZE wxSize(FromDIP(284), -1)
|
|
//#define AMS_CANS_WINDOW_SIZE wxSize(FromDIP(264), 144)
|
|
//#define AMS_SINGLE_CAN_SIZE wxSize(FromDIP(78), 144)
|
|
#define AMS_CANS_WINDOW_SIZE wxSize(FromDIP(264), FromDIP(174))
|
|
#define AMS_SINGLE_CAN_SIZE wxSize(FromDIP(78), FromDIP(174))
|
|
bool AMSinfo::parse_ams_info(MachineObject *obj, Ams *ams, bool remain_flag, bool humidity_flag)
|
|
{
|
|
if (!ams) return false;
|
|
this->ams_id = ams->id;
|
|
|
|
if (ams->type == 1 || ams->type == 3){
|
|
this->ams_humidity = ams->humidity;
|
|
}
|
|
else{
|
|
this->ams_humidity = -1;
|
|
}
|
|
this->ams_type = AMSModel(ams->type);
|
|
|
|
nozzle_id = ams->nozzle;
|
|
cans.clear();
|
|
for (int i = 0; i < ams->trayList.size(); i++) {
|
|
auto it = ams->trayList.find(std::to_string(i));
|
|
Caninfo info;
|
|
// tray is exists
|
|
if (it != ams->trayList.end() && it->second->is_exists) {
|
|
if (it->second->is_tray_info_ready()) {
|
|
info.can_id = it->second->id;
|
|
info.ctype = it->second->ctype;
|
|
info.material_name = it->second->get_display_filament_type();
|
|
info.cali_idx = it->second->cali_idx;
|
|
info.filament_id = it->second->setting_id;
|
|
if (!it->second->color.empty()) {
|
|
info.material_colour = AmsTray::decode_color(it->second->color);
|
|
} else {
|
|
// set to white by default
|
|
info.material_colour = AMS_TRAY_DEFAULT_COL;
|
|
}
|
|
|
|
for (std::string cols:it->second->cols) {
|
|
info.material_cols.push_back(AmsTray::decode_color(cols));
|
|
}
|
|
|
|
if (MachineObject::is_bbl_filament(it->second->tag_uid)) {
|
|
info.material_state = AMSCanType::AMS_CAN_TYPE_BRAND;
|
|
} else {
|
|
info.material_state = AMSCanType::AMS_CAN_TYPE_THIRDBRAND;
|
|
}
|
|
|
|
if (!MachineObject::is_bbl_filament(it->second->tag_uid) || !remain_flag) {
|
|
info.material_remain = 100;
|
|
} else {
|
|
if(it->second->remain < 0 || it->second->remain > 100) {
|
|
info.material_remain = 100;/*ignore the invalid data*/
|
|
} else {
|
|
info.material_remain = it->second->remain;
|
|
}
|
|
}
|
|
|
|
|
|
} else {
|
|
info.can_id = it->second->id;
|
|
info.material_name = "";
|
|
info.cali_idx = -1;
|
|
info.filament_id = "";
|
|
info.ctype = 0;
|
|
info.material_colour = AMS_TRAY_DEFAULT_COL;
|
|
info.material_state = AMSCanType::AMS_CAN_TYPE_THIRDBRAND;
|
|
wxColour(255, 255, 255);
|
|
}
|
|
|
|
if (it->second->is_tray_info_ready() && obj->cali_version >= 0) {
|
|
CalibUtils::get_pa_k_n_value_by_cali_idx(obj, it->second->cali_idx, info.k, info.n);
|
|
}
|
|
else {
|
|
info.k = it->second->k;
|
|
info.n = it->second->n;
|
|
}
|
|
} else {
|
|
//info.can_id = i;
|
|
info.can_id = std::to_string(i);
|
|
info.material_state = AMSCanType::AMS_CAN_TYPE_EMPTY;
|
|
}
|
|
cans.push_back(info);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void AMSinfo::parse_ext_info(MachineObject* obj, AmsTray tray) {
|
|
|
|
this->ams_id = tray.id;
|
|
this->ams_type = AMSModel::EXT_AMS;
|
|
Caninfo info;
|
|
info.can_id = std::to_string(0);
|
|
this->cans.clear();
|
|
|
|
if (tray.id == std::to_string(VIRTUAL_TRAY_MAIN_ID))
|
|
this->nozzle_id = 0;
|
|
else if (tray.id == std::to_string(VIRTUAL_TRAY_DEPUTY_ID))
|
|
this->nozzle_id = 1;
|
|
|
|
if (tray.is_tray_info_ready()) {
|
|
info.ctype = tray.ctype;
|
|
info.material_name = tray.get_display_filament_type();
|
|
info.cali_idx = tray.cali_idx;
|
|
info.filament_id = tray.setting_id;
|
|
if (!tray.color.empty()) {
|
|
info.material_colour = AmsTray::decode_color(tray.color);
|
|
}
|
|
else {
|
|
// set to white by default
|
|
info.material_colour = AMS_TRAY_DEFAULT_COL;
|
|
}
|
|
|
|
for (std::string cols : tray.cols) {
|
|
info.material_cols.push_back(AmsTray::decode_color(cols));
|
|
}
|
|
info.material_remain = 100;
|
|
}
|
|
else {
|
|
info.material_name = "";
|
|
info.cali_idx = -1;
|
|
info.filament_id = "";
|
|
info.ctype = 0;
|
|
info.material_colour = AMS_TRAY_DEFAULT_COL;
|
|
wxColour(255, 255, 255);
|
|
}
|
|
info.material_state = AMSCanType::AMS_CAN_TYPE_VIRTUAL;
|
|
if (tray.is_tray_info_ready() && obj->cali_version >= 0) {
|
|
CalibUtils::get_pa_k_n_value_by_cali_idx(obj, tray.cali_idx, info.k, info.n);
|
|
}
|
|
else {
|
|
info.k = tray.k;
|
|
info.n = tray.n;
|
|
}
|
|
this->cans.push_back(info);
|
|
}
|
|
|
|
/*************************************************
|
|
Description:AMSExtText
|
|
**************************************************/
|
|
|
|
AMSExtText::AMSExtText(wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size)
|
|
{
|
|
wxWindow::Create(parent, id, pos, AMS_REFRESH_SIZE);
|
|
SetBackgroundColour(StateColor::darkModeColorFor(AMS_CONTROL_DEF_LIB_BK_COLOUR));
|
|
|
|
Bind(wxEVT_PAINT, &AMSExtText::paintEvent, this);
|
|
SetSize(AMS_REFRESH_SIZE);
|
|
SetMinSize(AMS_REFRESH_SIZE);
|
|
}
|
|
|
|
AMSExtText::~AMSExtText() {}
|
|
|
|
void AMSExtText::msw_rescale()
|
|
{
|
|
Layout();
|
|
Fit();
|
|
Refresh();
|
|
}
|
|
|
|
void AMSExtText::paintEvent(wxPaintEvent& evt)
|
|
{
|
|
wxPaintDC dc(this);
|
|
render(dc);
|
|
}
|
|
|
|
void AMSExtText::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 AMSExtText::doRender(wxDC& dc)
|
|
{
|
|
auto size = GetSize();
|
|
|
|
dc.SetPen(wxPen(StateColor::darkModeColorFor(AMS_CONTROL_GRAY800), 2, wxPENSTYLE_SOLID));
|
|
auto tsize = dc.GetMultiLineTextExtent(_L("Ext"));
|
|
dc.SetFont(Label::Body_13);
|
|
dc.SetTextForeground(StateColor::darkModeColorFor(AMS_CONTROL_GRAY800));
|
|
wxPoint pot(FromDIP((size.x - tsize.x) / 2), FromDIP((size.y - tsize.y) / 2));
|
|
dc.DrawText(_L("Ext"), pot);
|
|
}
|
|
|
|
|
|
/*************************************************
|
|
Description:AMSrefresh
|
|
**************************************************/
|
|
|
|
AMSrefresh::AMSrefresh() { SetFont(Label::Body_10);}
|
|
|
|
AMSrefresh::AMSrefresh(wxWindow *parent, std::string ams_id, wxString can_id, Caninfo info, const wxPoint &pos, const wxSize &size) : AMSrefresh()
|
|
{
|
|
m_can_id = can_id.ToStdString();
|
|
create(parent, wxID_ANY, pos, size);
|
|
|
|
Update(ams_id, info);
|
|
}
|
|
|
|
AMSrefresh::AMSrefresh(wxWindow *parent, std::string ams_id, int can_id, Caninfo info, const wxPoint &pos, const wxSize &size) : AMSrefresh()
|
|
{
|
|
m_can_id = wxString::Format("%d", can_id).ToStdString();
|
|
create(parent, wxID_ANY, pos, size);
|
|
|
|
Update(ams_id, info);
|
|
}
|
|
|
|
AMSrefresh::~AMSrefresh()
|
|
{
|
|
if (m_playing_timer) {
|
|
m_playing_timer->Stop();
|
|
delete m_playing_timer;
|
|
m_playing_timer = nullptr;
|
|
}
|
|
}
|
|
|
|
void AMSrefresh::create(wxWindow *parent, wxWindowID id, const wxPoint &pos, const wxSize &size)
|
|
{
|
|
wxWindow::Create(parent, id, pos, size, wxBORDER_NONE);
|
|
SetBackgroundColour(StateColor::darkModeColorFor(AMS_CONTROL_DEF_LIB_BK_COLOUR));
|
|
|
|
Bind(wxEVT_TIMER, &AMSrefresh::on_timer, this);
|
|
Bind(wxEVT_PAINT, &AMSrefresh::paintEvent, this);
|
|
Bind(wxEVT_ENTER_WINDOW, &AMSrefresh::OnEnterWindow, this);
|
|
Bind(wxEVT_LEAVE_WINDOW, &AMSrefresh::OnLeaveWindow, this);
|
|
Bind(wxEVT_LEFT_DOWN, &AMSrefresh::OnClick, this);
|
|
|
|
m_bitmap_normal = ScalableBitmap(this, "ams_refresh_normal", 32);
|
|
m_bitmap_selected = ScalableBitmap(this, "ams_refresh_selected", 32);
|
|
|
|
m_bitmap_ams_rfid_0 = ScalableBitmap(this, "ams_rfid_0", 32);
|
|
m_bitmap_ams_rfid_1 = ScalableBitmap(this, "ams_rfid_1", 32);
|
|
m_bitmap_ams_rfid_2 = ScalableBitmap(this, "ams_rfid_2", 32);
|
|
m_bitmap_ams_rfid_3 = ScalableBitmap(this, "ams_rfid_3", 32);
|
|
m_bitmap_ams_rfid_4 = ScalableBitmap(this, "ams_rfid_4", 32);
|
|
m_bitmap_ams_rfid_5 = ScalableBitmap(this, "ams_rfid_5", 32);
|
|
m_bitmap_ams_rfid_6 = ScalableBitmap(this, "ams_rfid_6", 32);
|
|
m_bitmap_ams_rfid_7 = ScalableBitmap(this, "ams_rfid_7", 32);
|
|
|
|
m_rfid_bitmap_list.push_back(m_bitmap_ams_rfid_0);
|
|
m_rfid_bitmap_list.push_back(m_bitmap_ams_rfid_1);
|
|
m_rfid_bitmap_list.push_back(m_bitmap_ams_rfid_2);
|
|
m_rfid_bitmap_list.push_back(m_bitmap_ams_rfid_3);
|
|
m_rfid_bitmap_list.push_back(m_bitmap_ams_rfid_4);
|
|
m_rfid_bitmap_list.push_back(m_bitmap_ams_rfid_5);
|
|
m_rfid_bitmap_list.push_back(m_bitmap_ams_rfid_6);
|
|
m_rfid_bitmap_list.push_back(m_bitmap_ams_rfid_7);
|
|
|
|
m_playing_timer = new wxTimer();
|
|
m_playing_timer->SetOwner(this);
|
|
wxPostEvent(this, wxTimerEvent());
|
|
|
|
SetSize(AMS_REFRESH_SIZE);
|
|
SetMinSize(AMS_REFRESH_SIZE);
|
|
SetMaxSize(AMS_REFRESH_SIZE);
|
|
}
|
|
|
|
void AMSrefresh::on_timer(wxTimerEvent &event)
|
|
{
|
|
//if (m_rotation_angle >= m_rfid_bitmap_list.size()) {
|
|
// m_rotation_angle = 0;
|
|
//} else {
|
|
// m_rotation_angle++;
|
|
//}
|
|
Refresh();
|
|
}
|
|
|
|
void AMSrefresh::PlayLoading()
|
|
{
|
|
if (m_play_loading || m_disable_mode) return;
|
|
|
|
m_play_loading = true;
|
|
m_playing_timer->Start(AMS_REFRESH_PLAY_LOADING_TIMER);
|
|
Refresh();
|
|
}
|
|
|
|
void AMSrefresh::StopLoading()
|
|
{
|
|
if (!m_play_loading || m_disable_mode) return;
|
|
|
|
m_playing_timer->Stop();
|
|
m_play_loading = false;
|
|
Refresh();
|
|
}
|
|
|
|
void AMSrefresh::OnEnterWindow(wxMouseEvent &evt)
|
|
{
|
|
m_selected = true;
|
|
Refresh();
|
|
}
|
|
|
|
void AMSrefresh::OnLeaveWindow(wxMouseEvent &evt)
|
|
{
|
|
m_selected = false;
|
|
Refresh();
|
|
}
|
|
|
|
void AMSrefresh::OnClick(wxMouseEvent &evt) {
|
|
post_event(wxCommandEvent(EVT_AMS_REFRESH_RFID));
|
|
}
|
|
|
|
void AMSrefresh::post_event(wxCommandEvent &&event)
|
|
{
|
|
if (m_play_loading) { return;}
|
|
|
|
if (m_disable_mode)
|
|
return;
|
|
event.SetString(m_info.can_id);
|
|
event.SetInt(atoi(m_ams_id.c_str()));
|
|
event.SetEventObject(m_parent);
|
|
wxPostEvent(m_parent, event);
|
|
event.Skip();
|
|
}
|
|
|
|
void AMSrefresh::paintEvent(wxPaintEvent &evt)
|
|
{
|
|
wxSize size = GetSize();
|
|
wxPaintDC dc(this);
|
|
|
|
auto colour = StateColor::darkModeColorFor(AMS_CONTROL_GRAY700);
|
|
if (!wxWindow::IsEnabled()) { colour = StateColor::darkModeColorFor(AMS_CONTROL_GRAY500); }
|
|
|
|
auto pot = wxPoint((size.x - m_bitmap_selected.GetBmpSize().x) / 2, (size.y - m_bitmap_selected.GetBmpSize().y) / 2);
|
|
|
|
if (!m_disable_mode) {
|
|
if (!m_play_loading) {
|
|
dc.DrawBitmap(m_selected ? m_bitmap_selected.bmp() : m_bitmap_normal.bmp(), pot);
|
|
}
|
|
else {
|
|
/* m_bitmap_rotation = ScalableBitmap(this, "ams_refresh_normal", 30);
|
|
auto image = m_bitmap_rotation.bmp().ConvertToImage();
|
|
wxPoint offset;
|
|
auto loading_img = image.Rotate(m_rotation_angle, wxPoint(image.GetWidth() / 2, image.GetHeight() / 2), true, &offset);
|
|
ScalableBitmap loading_bitmap;
|
|
loading_bitmap.bmp() = wxBitmap(loading_img);
|
|
dc.DrawBitmap(loading_bitmap.bmp(), offset.x , offset.y);*/
|
|
m_rotation_angle++;
|
|
if (m_rotation_angle >= m_rfid_bitmap_list.size()) {
|
|
m_rotation_angle = 0;
|
|
}
|
|
if (m_rfid_bitmap_list.size() <= 0)return;
|
|
dc.DrawBitmap(m_rfid_bitmap_list[m_rotation_angle].bmp(), pot);
|
|
}
|
|
}
|
|
|
|
dc.SetFont(Label::Body_10);
|
|
//dc.SetTextForeground(StateColor::darkModeColorFor(AMS_CONTROL_BLACK_COLOUR));
|
|
dc.SetTextForeground(colour);
|
|
auto tsize = dc.GetTextExtent(m_refresh_id);
|
|
pot = wxPoint((size.x - tsize.x) / 2, (size.y - tsize.y) / 2);
|
|
dc.DrawText(m_refresh_id, pot);
|
|
}
|
|
|
|
void AMSrefresh::Update(std::string ams_id, Caninfo info)
|
|
{
|
|
if (m_ams_id == ams_id && m_info == info)
|
|
{
|
|
return;
|
|
}
|
|
|
|
m_ams_id = ams_id;
|
|
m_info = info;
|
|
|
|
if (!m_ams_id.empty() && !m_can_id.empty()) {
|
|
auto aid = atoi(m_ams_id.c_str());
|
|
auto tid = atoi(m_can_id.c_str());
|
|
auto tray_id = aid * 4 + tid;
|
|
m_refresh_id = wxGetApp().transition_tridid(tray_id);
|
|
}
|
|
|
|
Refresh();
|
|
}
|
|
|
|
void AMSrefresh::msw_rescale() {
|
|
m_bitmap_normal = ScalableBitmap(this, "ams_refresh_normal", 32);
|
|
m_bitmap_selected = ScalableBitmap(this, "ams_refresh_selected", 32);
|
|
m_bitmap_ams_rfid_0 = ScalableBitmap(this, "ams_rfid_0", 32);
|
|
m_bitmap_ams_rfid_1 = ScalableBitmap(this, "ams_rfid_1", 32);
|
|
m_bitmap_ams_rfid_2 = ScalableBitmap(this, "ams_rfid_2", 32);
|
|
m_bitmap_ams_rfid_3 = ScalableBitmap(this, "ams_rfid_3", 32);
|
|
m_bitmap_ams_rfid_4 = ScalableBitmap(this, "ams_rfid_4", 32);
|
|
m_bitmap_ams_rfid_5 = ScalableBitmap(this, "ams_rfid_5", 32);
|
|
m_bitmap_ams_rfid_6 = ScalableBitmap(this, "ams_rfid_6", 32);
|
|
m_bitmap_ams_rfid_7 = ScalableBitmap(this, "ams_rfid_7", 32);
|
|
|
|
m_rfid_bitmap_list.clear();
|
|
m_rfid_bitmap_list.push_back(m_bitmap_ams_rfid_0);
|
|
m_rfid_bitmap_list.push_back(m_bitmap_ams_rfid_1);
|
|
m_rfid_bitmap_list.push_back(m_bitmap_ams_rfid_2);
|
|
m_rfid_bitmap_list.push_back(m_bitmap_ams_rfid_3);
|
|
m_rfid_bitmap_list.push_back(m_bitmap_ams_rfid_4);
|
|
m_rfid_bitmap_list.push_back(m_bitmap_ams_rfid_5);
|
|
m_rfid_bitmap_list.push_back(m_bitmap_ams_rfid_6);
|
|
m_rfid_bitmap_list.push_back(m_bitmap_ams_rfid_7);
|
|
|
|
Layout();
|
|
Refresh();
|
|
}
|
|
|
|
void AMSrefresh::DoSetSize(int x, int y, int width, int height, int sizeFlags)
|
|
{
|
|
wxWindow::DoSetSize(x, y, width, height, sizeFlags);
|
|
}
|
|
|
|
/*************************************************
|
|
Description:AMSextruder
|
|
**************************************************/
|
|
void AMSextruderImage::OnAmsLoading(bool load, wxColour col)
|
|
{
|
|
if (m_ams_loading != load || m_colour != col) {
|
|
m_ams_loading = load;
|
|
m_colour = col;
|
|
Refresh();
|
|
}
|
|
}
|
|
|
|
void AMSextruderImage::TurnOff()
|
|
{
|
|
m_colour = AMS_EXTRUDER_DEF_COLOUR;
|
|
Refresh();
|
|
}
|
|
|
|
void AMSextruderImage::msw_rescale()
|
|
{
|
|
//m_ams_extruder.SetSize(AMS_EXTRUDER_BITMAP_SIZE);
|
|
//auto image = m_ams_extruder.ConvertToImage();
|
|
m_ams_extruder = ScalableBitmap(this, m_file_name, 36);
|
|
Layout();
|
|
Refresh();
|
|
}
|
|
|
|
void AMSextruderImage::paintEvent(wxPaintEvent &evt)
|
|
{
|
|
wxPaintDC dc(this);
|
|
render(dc);
|
|
}
|
|
|
|
void AMSextruderImage::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 AMSextruderImage::doRender(wxDC &dc)
|
|
{
|
|
auto size = GetSize();
|
|
//dc.DrawRectangle(0, FromDIP(5), size.x, size.y - FromDIP(5) - FromDIP(2));
|
|
if (m_show_state){
|
|
if (m_ams_loading) {
|
|
dc.SetPen(*wxTRANSPARENT_PEN);
|
|
dc.SetBrush(m_colour);
|
|
dc.DrawRectangle(FromDIP(2), FromDIP(10), size.x - FromDIP(3), size.y - FromDIP(20));
|
|
}
|
|
else{
|
|
dc.SetPen(*wxTRANSPARENT_PEN);
|
|
dc.SetBrush(*wxWHITE);
|
|
dc.DrawRectangle(FromDIP(3), FromDIP(10), size.x - FromDIP(6), size.y - FromDIP(20));
|
|
}
|
|
dc.DrawBitmap(m_ams_extruder.bmp(), wxPoint((size.x - m_ams_extruder.GetBmpSize().x) / 2, 0));
|
|
}
|
|
}
|
|
|
|
|
|
AMSextruderImage::AMSextruderImage(wxWindow *parent, wxWindowID id, string file_name, const wxSize& size, const wxPoint &pos)
|
|
{
|
|
wxWindow::Create(parent, id, pos, size);
|
|
SetBackgroundColour(StateColor::darkModeColorFor(*wxWHITE));
|
|
|
|
m_ams_extruder = ScalableBitmap(this, file_name,36);
|
|
m_file_name = file_name;
|
|
SetSize(size);
|
|
SetMinSize(size);
|
|
SetMaxSize(size);
|
|
|
|
|
|
Bind(wxEVT_PAINT, &AMSextruderImage::paintEvent, this);
|
|
}
|
|
|
|
AMSextruderImage::~AMSextruderImage() {}
|
|
|
|
|
|
|
|
|
|
/*************************************************
|
|
Description:AMSExtImage upon ext lib
|
|
**************************************************/
|
|
|
|
AMSExtImage::AMSExtImage(wxWindow* parent, AMSPanelPos ext_pos, ExtderData *data, wxWindowID id, const wxPoint& pos)
|
|
{
|
|
if (data == nullptr)
|
|
{
|
|
wxWindow::Create(parent, id, pos, AMS_HUMIDITY_SIZE);
|
|
m_show_ams_ext = true;
|
|
}
|
|
else
|
|
{
|
|
wxWindow::Create(parent, id, pos, wxSize(FromDIP(98), FromDIP(99)));
|
|
m_show_ext = true;
|
|
total_ext_num = data->total_extder_count;
|
|
}
|
|
|
|
m_ext_pos = ext_pos;
|
|
m_ext_left = ScalableBitmap(this, "ext_image_left", 98);
|
|
m_ext_right = ScalableBitmap(this, "ext_image_right", 98);
|
|
m_ext_single_nozzle = ScalableBitmap(this, "ext_image_single_nozzle", 98);
|
|
|
|
m_ams_single_ext = ScalableBitmap(this, "ams_ext_image", 25);
|
|
m_ams_ext_left = ScalableBitmap(this, "ext_image_left", 25);
|
|
m_ams_ext_right = ScalableBitmap(this, "ext_image_right", 25);
|
|
|
|
SetBackgroundColour(StateColor::darkModeColorFor(AMS_CONTROL_DEF_LIB_BK_COLOUR));
|
|
|
|
Bind(wxEVT_PAINT, &AMSExtImage::paintEvent, this);
|
|
}
|
|
|
|
AMSExtImage::~AMSExtImage() {}
|
|
|
|
void AMSExtImage::msw_rescale()
|
|
{
|
|
//m_ams_extruder.SetSize(AMS_EXTRUDER_BITMAP_SIZE);
|
|
//auto image = m_ams_extruder.ConvertToImage();
|
|
m_ext_left = ScalableBitmap(this, "ext_image_left", 98);
|
|
m_ext_right = ScalableBitmap(this, "ext_image_right", 98);
|
|
m_ext_single_nozzle = ScalableBitmap(this, "ext_image_single_nozzle", 98);
|
|
|
|
m_ams_single_ext = ScalableBitmap(this, "ams_ext_image", 25);
|
|
m_ams_ext_left = ScalableBitmap(this, "ext_image_left", 25);
|
|
m_ams_ext_right = ScalableBitmap(this, "ext_image_right", 25);
|
|
|
|
Layout();
|
|
Fit();
|
|
Refresh();
|
|
}
|
|
|
|
void AMSExtImage::setShowAmsExt(bool show)
|
|
{
|
|
if (m_show_ams_ext != show)
|
|
{
|
|
m_show_ams_ext = show;
|
|
Refresh();
|
|
}
|
|
}
|
|
|
|
void AMSExtImage::setTotalExtNum(int num)
|
|
{
|
|
if (total_ext_num != num)
|
|
{
|
|
total_ext_num = num;
|
|
Refresh();
|
|
}
|
|
}
|
|
|
|
void AMSExtImage::paintEvent(wxPaintEvent& evt)
|
|
{
|
|
wxPaintDC dc(this);
|
|
render(dc);
|
|
}
|
|
|
|
void AMSExtImage::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 AMSExtImage::doRender(wxDC& dc)
|
|
{
|
|
auto size = GetSize();
|
|
dc.SetPen(*wxTRANSPARENT_PEN);
|
|
|
|
if (m_show_ams_ext)
|
|
{
|
|
if (total_ext_num < 2)
|
|
{
|
|
dc.DrawBitmap(m_ams_single_ext.bmp(), wxPoint((size.x - m_ams_single_ext.GetBmpSize().x) / 2, 0));
|
|
}
|
|
else
|
|
{
|
|
if (m_ext_pos == AMSPanelPos::LEFT_PANEL)
|
|
{
|
|
dc.DrawBitmap(m_ams_ext_left.bmp(), wxPoint((size.x - m_ams_ext_left.GetBmpSize().x) / 2, 0));
|
|
}
|
|
else
|
|
{
|
|
dc.DrawBitmap(m_ams_ext_right.bmp(), wxPoint((size.x - m_ams_ext_right.GetBmpSize().x) / 2, 0));
|
|
}
|
|
}
|
|
|
|
Layout();
|
|
return;
|
|
}
|
|
|
|
if (m_show_ext)
|
|
{
|
|
if (total_ext_num < 2)
|
|
{
|
|
dc.DrawBitmap(m_ext_single_nozzle.bmp(), wxPoint((size.x - m_ext_right.GetBmpSize().x) / 2, (size.y - m_ext_right.GetBmpSize().y) / 2));
|
|
}
|
|
else
|
|
{
|
|
if (m_ext_pos == AMSPanelPos::LEFT_PANEL)
|
|
{
|
|
dc.DrawBitmap(m_ext_left.bmp(), wxPoint((size.x - m_ext_left.GetBmpSize().x) / 2, (size.y - m_ext_left.GetBmpSize().y) / 2));
|
|
}
|
|
else
|
|
{
|
|
dc.DrawBitmap(m_ext_right.bmp(), wxPoint((size.x - m_ext_right.GetBmpSize().x) / 2, (size.y - m_ext_right.GetBmpSize().y) / 2));
|
|
}
|
|
}
|
|
|
|
Layout();
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
//Ams Extruder
|
|
AMSextruder::AMSextruder(wxWindow *parent, wxWindowID id, int nozzle_num, const wxPoint &pos, const wxSize &size)
|
|
{
|
|
create(parent, id, pos, size, nozzle_num);
|
|
}
|
|
|
|
AMSextruder::~AMSextruder() {}
|
|
|
|
void AMSextruder::TurnOn(wxColour col)
|
|
{
|
|
//m_left_extruder->TurnOn(col);
|
|
}
|
|
|
|
void AMSextruder::TurnOff()
|
|
{
|
|
m_left_extruder->TurnOff();
|
|
}
|
|
|
|
void AMSextruder::create(wxWindow *parent, wxWindowID id, const wxPoint &pos, const wxSize &size, int nozzle_num)
|
|
{
|
|
wxWindow::Create(parent, id, pos, wxSize(-1, FromDIP(36)), wxBORDER_NONE);
|
|
SetBackgroundColour(*wxWHITE);
|
|
|
|
updateNozzleNum(nozzle_num);
|
|
Layout();
|
|
}
|
|
|
|
void AMSextruder::OnVamsLoading(bool load, wxColour col)
|
|
{
|
|
m_vams_loading = load;
|
|
if (load)m_current_colur = col;
|
|
Refresh();
|
|
}
|
|
|
|
void AMSextruder::OnAmsLoading(bool load, int nozzle_id, wxColour col /*= AMS_CONTROL_GRAY500*/)
|
|
{
|
|
m_ams_loading = load;
|
|
if (m_nozzle_num == 1){
|
|
m_left_extruder->OnAmsLoading(load, col);
|
|
if (load) m_current_colur_deputy = col;
|
|
}
|
|
else if (m_nozzle_num > 1){
|
|
if (nozzle_id == MAIN_NOZZLE_ID) {
|
|
m_right_extruder->OnAmsLoading(load, col);
|
|
if (m_current_colur != col){
|
|
if (load) m_current_colur = col;
|
|
}
|
|
}
|
|
else if(nozzle_id == DEPUTY_NOZZLE_ID) {
|
|
m_left_extruder->OnAmsLoading(load, col);
|
|
if (m_current_colur_deputy != col) {
|
|
if (load) m_current_colur_deputy = col;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void AMSextruder::updateNozzleNum(int nozzle_num)
|
|
{
|
|
if (m_nozzle_num == nozzle_num) return;
|
|
m_nozzle_num = nozzle_num;
|
|
this->DestroyChildren();
|
|
|
|
m_right_extruder = new AMSextruderImage(this, wxID_ANY, "right_nozzle", AMS_EXTRUDER_DOUBLE_NOZZLE_BITMAP_SIZE);
|
|
|
|
wxBoxSizer* m_bitmap_sizer = new wxBoxSizer(wxHORIZONTAL);
|
|
if (m_nozzle_num >= 2)
|
|
{
|
|
m_left_extruder = new AMSextruderImage(this, wxID_ANY, "left_nozzle", AMS_EXTRUDER_DOUBLE_NOZZLE_BITMAP_SIZE);
|
|
m_left_extruder->setShowState(true);
|
|
m_right_extruder->setShowState(true);
|
|
m_bitmap_sizer->Add(m_left_extruder, 0, wxALIGN_LEFT | wxALIGN_TOP, 0);
|
|
m_bitmap_sizer->Add(m_right_extruder, 0, wxLEFT | wxALIGN_TOP, FromDIP(2));
|
|
m_bitmap_sizer->AddSpacer(2);
|
|
}
|
|
else
|
|
{
|
|
m_left_extruder = new AMSextruderImage(this, wxID_ANY, "single_nozzle", AMS_EXTRUDER_SINGLE_NOZZLE_BITMAP_SIZE);
|
|
m_left_extruder->setShowState(true);
|
|
m_right_extruder->setShowState(false);
|
|
m_bitmap_sizer->Add(m_left_extruder, 0, wxALIGN_LEFT | wxALIGN_TOP, 0);
|
|
m_bitmap_sizer->Add(m_right_extruder, 0, wxLEFT | wxALIGN_TOP, FromDIP(3));
|
|
}
|
|
|
|
SetSizer(m_bitmap_sizer);
|
|
Refresh();
|
|
}
|
|
|
|
void AMSextruder::msw_rescale()
|
|
{
|
|
//m_amsSextruder->msw_rescale();
|
|
if (m_left_extruder) m_left_extruder->msw_rescale();
|
|
if (m_right_extruder) m_right_extruder->msw_rescale();
|
|
Layout();
|
|
Update();
|
|
Refresh();
|
|
}
|
|
|
|
/*************************************************
|
|
Description:AMSLib
|
|
**************************************************/
|
|
AMSLib::AMSLib(wxWindow *parent, std::string ams_idx, Caninfo info, AMSModelOriginType ext_type)
|
|
{
|
|
m_border_color = (wxColour(130, 130, 128));
|
|
m_road_def_color = AMS_CONTROL_GRAY500;
|
|
m_ext_type = ext_type;
|
|
wxWindow::SetBackgroundColour(StateColor::darkModeColorFor(AMS_CONTROL_DEF_LIB_BK_COLOUR));
|
|
create(parent);
|
|
|
|
Bind(wxEVT_PAINT, &AMSLib::paintEvent, this);
|
|
Bind(wxEVT_ENTER_WINDOW, &AMSLib::on_enter_window, this);
|
|
Bind(wxEVT_LEAVE_WINDOW, &AMSLib::on_leave_window, this);
|
|
Bind(wxEVT_LEFT_DOWN, &AMSLib::on_left_down, this);
|
|
|
|
Update(info, ams_idx, false);
|
|
}
|
|
|
|
AMSLib::~AMSLib()
|
|
{
|
|
}
|
|
|
|
void AMSLib::create(wxWindow *parent, wxWindowID id, const wxPoint &pos, const wxSize &size)
|
|
{
|
|
wxWindow::Create(parent, id, pos, size);
|
|
|
|
SetSize(AMS_CAN_LIB_SIZE);
|
|
SetMinSize(AMS_CAN_LIB_SIZE);
|
|
SetMaxSize(AMS_CAN_LIB_SIZE);
|
|
auto m_sizer_body = new wxBoxSizer(wxVERTICAL);
|
|
|
|
wxBoxSizer *m_sizer_edit = new wxBoxSizer(wxHORIZONTAL);
|
|
|
|
m_bitmap_editable = ScalableBitmap(this, "ams_editable", 14);
|
|
m_bitmap_editable_light = ScalableBitmap(this, "ams_editable_light", 14);
|
|
m_bitmap_readonly = ScalableBitmap(this, "ams_readonly", 14);
|
|
m_bitmap_readonly_light = ScalableBitmap(this, "ams_readonly_light", 14);
|
|
m_bitmap_transparent = ScalableBitmap(this, "transparent_ams_lib", 76);
|
|
m_bitmap_transparent_def = ScalableBitmap(this, "transparent_ams_lib", 76);
|
|
|
|
m_bitmap_extra_tray_left = ScalableBitmap(this, "extra_ams_tray_left", 72);
|
|
m_bitmap_extra_tray_right = ScalableBitmap(this, "extra_ams_tray_right", 72);
|
|
m_bitmap_extra_tray_mid = ScalableBitmap(this, "extra_ams_tray_mid", 72);
|
|
|
|
m_bitmap_extra_tray_left_hover = ScalableBitmap(this, "extra_ams_tray_left_hover", 72);
|
|
m_bitmap_extra_tray_right_hover = ScalableBitmap(this, "extra_ams_tray_right_hover", 72);
|
|
m_bitmap_extra_tray_mid_hover = ScalableBitmap(this, "extra_ams_tray_mid_hover", 72);
|
|
|
|
m_bitmap_extra_tray_left_selected = ScalableBitmap(this, "extra_ams_tray_left_selected", 72);
|
|
m_bitmap_extra_tray_right_selected = ScalableBitmap(this, "extra_ams_tray_right_selected", 72);
|
|
m_bitmap_extra_tray_mid_selected = ScalableBitmap(this, "extra_ams_tray_mid_selected", 72);
|
|
|
|
|
|
m_sizer_body->Add(0, 0, 1, wxEXPAND, 0);
|
|
m_sizer_body->Add(m_sizer_edit, 0, wxALIGN_CENTER, 0);
|
|
m_sizer_body->Add(0, 0, 0, wxBOTTOM, GetSize().y * 0.12);
|
|
SetSizer(m_sizer_body);
|
|
Layout();
|
|
}
|
|
|
|
void AMSLib::on_enter_window(wxMouseEvent &evt)
|
|
{
|
|
m_hover = true;
|
|
Refresh();
|
|
}
|
|
|
|
void AMSLib::on_leave_window(wxMouseEvent &evt)
|
|
{
|
|
m_hover = false;
|
|
Refresh();
|
|
}
|
|
|
|
void AMSLib::on_left_down(wxMouseEvent &evt)
|
|
{
|
|
if (m_info.material_state != AMSCanType::AMS_CAN_TYPE_EMPTY && m_info.material_state != AMSCanType::AMS_CAN_TYPE_NONE) {
|
|
auto size = GetSize();
|
|
auto pos = evt.GetPosition();
|
|
if (m_info.material_state == AMSCanType::AMS_CAN_TYPE_THIRDBRAND || m_info.material_state == AMSCanType::AMS_CAN_TYPE_BRAND ||
|
|
m_info.material_state == AMSCanType::AMS_CAN_TYPE_VIRTUAL) {
|
|
|
|
auto left = FromDIP(10);
|
|
auto right = size.x - FromDIP(10);
|
|
auto top = 0;
|
|
auto bottom = 0;
|
|
|
|
if (m_ams_model == AMSModel::GENERIC_AMS || m_ams_model == AMSModel::N3F_AMS || m_ams_model == AMSModel::N3S_AMS || m_ams_model == AMSModel::EXT_AMS) {
|
|
top = (size.y - FromDIP(15) - m_bitmap_editable_light.GetBmpSize().y);
|
|
bottom = size.y - FromDIP(15);
|
|
}
|
|
else if (m_ams_model == AMSModel::AMS_LITE) {
|
|
top = (size.y - FromDIP(20) - m_bitmap_editable_light.GetBmpSize().y);
|
|
bottom = size.y - FromDIP(20);
|
|
}
|
|
|
|
if (pos.x >= left && pos.x <= right && pos.y >= top && top <= bottom) {
|
|
if (m_selected) {
|
|
if (m_info.material_state == AMSCanType::AMS_CAN_TYPE_VIRTUAL) {
|
|
post_event(wxCommandEvent(EVT_VAMS_ON_FILAMENT_EDIT));
|
|
}
|
|
else {
|
|
post_event(wxCommandEvent(EVT_AMS_ON_FILAMENT_EDIT));
|
|
}
|
|
} else {
|
|
BOOST_LOG_TRIVIAL(trace) << "current amslib is not selected";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void AMSLib::paintEvent(wxPaintEvent &evt)
|
|
{
|
|
wxPaintDC dc(this);
|
|
render(dc);
|
|
}
|
|
|
|
void AMSLib::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
|
|
|
|
// text
|
|
if (m_ams_model == AMSModel::AMS_LITE || (m_ams_model == AMSModel::EXT_AMS && m_ext_type == AMSModelOriginType::LITE_EXT)) {
|
|
render_lite_text(dc);
|
|
}
|
|
else{
|
|
render_generic_text(dc);
|
|
}
|
|
}
|
|
|
|
void AMSLib::render_lite_text(wxDC& dc)
|
|
{
|
|
auto tmp_lib_colour = m_info.material_colour;
|
|
|
|
change_the_opacity(tmp_lib_colour);
|
|
auto temp_text_colour = AMS_CONTROL_GRAY800;
|
|
|
|
if (tmp_lib_colour.GetLuminance() < 0.6) {
|
|
temp_text_colour = AMS_CONTROL_WHITE_COLOUR;
|
|
}
|
|
else {
|
|
temp_text_colour = AMS_CONTROL_GRAY800;
|
|
}
|
|
|
|
if (m_info.material_remain < 50) {
|
|
temp_text_colour = AMS_CONTROL_GRAY800;
|
|
}
|
|
|
|
if (tmp_lib_colour.Alpha() == 0) {
|
|
temp_text_colour = AMS_CONTROL_GRAY800;
|
|
}
|
|
|
|
dc.SetFont(::Label::Body_13);
|
|
dc.SetTextForeground(temp_text_colour);
|
|
|
|
auto libsize = GetSize();
|
|
if (m_info.material_state == AMSCanType::AMS_CAN_TYPE_THIRDBRAND
|
|
|| m_info.material_state == AMSCanType::AMS_CAN_TYPE_BRAND
|
|
|| m_info.material_state == AMSCanType::AMS_CAN_TYPE_VIRTUAL) {
|
|
|
|
if (m_info.material_name.empty()) {
|
|
auto tsize = dc.GetMultiLineTextExtent("?");
|
|
auto pot = wxPoint(0, 0);
|
|
pot = wxPoint((libsize.x - tsize.x) / 2 + FromDIP(2), (libsize.y - tsize.y) / 2 - FromDIP(5));
|
|
dc.DrawText(L("?"), pot);
|
|
}
|
|
else {
|
|
auto tsize = dc.GetMultiLineTextExtent(m_info.material_name);
|
|
std::vector<std::string> split_char_arr = { " ", "-" };
|
|
bool has_split = false;
|
|
std::string has_split_char = " ";
|
|
|
|
for (std::string split_char : split_char_arr) {
|
|
if (m_info.material_name.find(split_char) != std::string::npos) {
|
|
has_split = true;
|
|
has_split_char = split_char;
|
|
}
|
|
}
|
|
|
|
if (has_split) {
|
|
dc.SetFont(::Label::Body_10);
|
|
auto line_top = m_info.material_name.substr(0, m_info.material_name.find(has_split_char));
|
|
auto line_bottom = m_info.material_name.substr(m_info.material_name.find(has_split_char));
|
|
|
|
auto line_top_tsize = dc.GetMultiLineTextExtent(line_top);
|
|
auto line_bottom_tsize = dc.GetMultiLineTextExtent(line_bottom);
|
|
|
|
auto pot_top = wxPoint((libsize.x - line_top_tsize.x) / 2 + FromDIP(3), (libsize.y - line_top_tsize.y) / 2 - line_top_tsize.y);
|
|
dc.DrawText(line_top, pot_top);
|
|
|
|
auto pot_bottom = wxPoint((libsize.x - line_bottom_tsize.x) / 2 + FromDIP(3), (libsize.y - line_bottom_tsize.y) / 2);
|
|
dc.DrawText(line_bottom, pot_bottom);
|
|
|
|
|
|
}
|
|
else {
|
|
dc.SetFont(::Label::Body_10);
|
|
auto pot = wxPoint(0, 0);
|
|
if (m_obj ) {
|
|
pot = wxPoint((libsize.x - tsize.x) / 2 + FromDIP(6), (libsize.y - tsize.y) / 2 - FromDIP(5));
|
|
}
|
|
dc.DrawText(m_info.material_name, pot);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (m_info.material_state == AMSCanType::AMS_CAN_TYPE_EMPTY) {
|
|
auto tsize = dc.GetMultiLineTextExtent(_L("/"));
|
|
auto pot = wxPoint((libsize.x - tsize.x) / 2 + FromDIP(2), (libsize.y - tsize.y) / 2 + FromDIP(3));
|
|
dc.DrawText(_L("/"), pot);
|
|
}
|
|
}
|
|
|
|
void AMSLib::render_generic_text(wxDC &dc)
|
|
{
|
|
bool show_k_value = true;
|
|
if (m_info.material_name.empty()) {
|
|
show_k_value = false;
|
|
}
|
|
else if (m_info.cali_idx == -1 || (m_obj && (CalibUtils::get_selected_calib_idx(m_obj->pa_calib_tab, m_info.cali_idx) == -1))) {
|
|
if (m_obj && m_obj->is_multi_extruders())
|
|
show_k_value = false;
|
|
else
|
|
get_default_k_n_value(m_info.filament_id, m_info.k, m_info.n);
|
|
}
|
|
else if (abs(m_info.k) < EPSILON) {
|
|
show_k_value = false;
|
|
}
|
|
|
|
auto tmp_lib_colour = m_info.material_colour;
|
|
change_the_opacity(tmp_lib_colour);
|
|
|
|
auto temp_text_colour = AMS_CONTROL_GRAY800;
|
|
|
|
if (tmp_lib_colour.GetLuminance() < 0.6) {
|
|
temp_text_colour = AMS_CONTROL_WHITE_COLOUR;
|
|
}
|
|
else {
|
|
temp_text_colour = AMS_CONTROL_GRAY800;
|
|
}
|
|
|
|
if (m_info.material_remain < 50) {
|
|
temp_text_colour = AMS_CONTROL_GRAY800;
|
|
}
|
|
|
|
if (tmp_lib_colour.Alpha() == 0) {
|
|
temp_text_colour = AMS_CONTROL_GRAY800;
|
|
}
|
|
|
|
dc.SetFont(::Label::Body_13);
|
|
dc.SetTextForeground(temp_text_colour);
|
|
auto alpha = m_info.material_colour.Alpha();
|
|
if (alpha != 0 && alpha != 255 && alpha != 254) {
|
|
dc.SetTextForeground(*wxBLACK);
|
|
}
|
|
|
|
auto libsize = GetSize();
|
|
if (m_info.material_state == AMSCanType::AMS_CAN_TYPE_THIRDBRAND
|
|
|| m_info.material_state == AMSCanType::AMS_CAN_TYPE_BRAND
|
|
|| m_info.material_state == AMSCanType::AMS_CAN_TYPE_VIRTUAL) {
|
|
|
|
if (m_info.material_name.empty() /*&& m_info.material_state != AMSCanType::AMS_CAN_TYPE_VIRTUAL*/) {
|
|
auto tsize = dc.GetMultiLineTextExtent("?");
|
|
auto pot = wxPoint(0, 0);
|
|
|
|
if (m_obj && show_k_value) {
|
|
pot = wxPoint((libsize.x - tsize.x) / 2, (libsize.y - tsize.y) / 2 - FromDIP(9));
|
|
}
|
|
else {
|
|
pot = wxPoint((libsize.x - tsize.x) / 2, (libsize.y - tsize.y) / 2 + FromDIP(3));
|
|
}
|
|
dc.DrawText(L("?"), pot);
|
|
|
|
}
|
|
else {
|
|
auto tsize = dc.GetMultiLineTextExtent(m_info.material_name);
|
|
std::vector<std::string> split_char_arr = { " ", "-" };
|
|
bool has_split = false;
|
|
std::string has_split_char = " ";
|
|
|
|
for (std::string split_char : split_char_arr) {
|
|
if (m_info.material_name.find(split_char) != std::string::npos) {
|
|
has_split = true;
|
|
has_split_char = split_char;
|
|
}
|
|
}
|
|
|
|
|
|
if (has_split) {
|
|
dc.SetFont(::Label::Body_12);
|
|
|
|
auto line_top = m_info.material_name.substr(0, m_info.material_name.find(has_split_char));
|
|
auto line_bottom = m_info.material_name.substr(m_info.material_name.find(has_split_char));
|
|
|
|
auto line_top_tsize = dc.GetMultiLineTextExtent(line_top);
|
|
auto line_bottom_tsize = dc.GetMultiLineTextExtent(line_bottom);
|
|
|
|
if (!m_show_kn) {
|
|
auto pot_top = wxPoint((libsize.x - line_top_tsize.x) / 2, (libsize.y - line_top_tsize.y) / 2 - line_top_tsize.y + FromDIP(6));
|
|
dc.DrawText(line_top, pot_top);
|
|
|
|
|
|
auto pot_bottom = wxPoint((libsize.x - line_bottom_tsize.x) / 2, (libsize.y - line_bottom_tsize.y) / 2 + FromDIP(4));
|
|
dc.DrawText(line_bottom, pot_bottom);
|
|
}
|
|
else {
|
|
auto pot_top = wxPoint((libsize.x - line_top_tsize.x) / 2, (libsize.y - line_top_tsize.y) / 2 - line_top_tsize.y - FromDIP(6));
|
|
dc.DrawText(line_top, pot_top);
|
|
|
|
auto pot_bottom = wxPoint((libsize.x - line_bottom_tsize.x) / 2, (libsize.y - line_bottom_tsize.y) / 2 - FromDIP(8));
|
|
dc.DrawText(line_bottom, pot_bottom);
|
|
}
|
|
|
|
|
|
}
|
|
else {
|
|
auto pot = wxPoint(0, 0);
|
|
if (m_obj && show_k_value) {
|
|
pot = wxPoint((libsize.x - tsize.x) / 2, (libsize.y - tsize.y) / 2 - FromDIP(9));
|
|
} else {
|
|
pot = wxPoint((libsize.x - tsize.x) / 2, (libsize.y - tsize.y) / 2 + FromDIP(3));
|
|
}
|
|
dc.DrawText(m_info.material_name, pot);
|
|
}
|
|
}
|
|
|
|
//draw k&n
|
|
if (m_obj && show_k_value) {
|
|
if (m_show_kn) {
|
|
wxString str_k = wxString::Format("K %1.3f", m_info.k);
|
|
wxString str_n = wxString::Format("N %1.3f", m_info.n);
|
|
dc.SetFont(::Label::Body_11);
|
|
auto tsize = dc.GetMultiLineTextExtent(str_k);
|
|
auto pot_k = wxPoint((libsize.x - tsize.x) / 2, (libsize.y - tsize.y) / 2 - FromDIP(9) + tsize.y);
|
|
dc.DrawText(str_k, pot_k);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (m_info.material_state == AMSCanType::AMS_CAN_TYPE_EMPTY) {
|
|
auto tsize = dc.GetMultiLineTextExtent(_L("Empty"));
|
|
auto pot = wxPoint((libsize.x - tsize.x) / 2, (libsize.y - tsize.y) / 2 + FromDIP(3));
|
|
dc.DrawText(_L("Empty"), pot);
|
|
}
|
|
}
|
|
|
|
void AMSLib::doRender(wxDC &dc)
|
|
{
|
|
if (m_ams_model == AMSModel::AMS_LITE || m_ext_type == AMSModelOriginType::LITE_EXT) {
|
|
render_lite_lib(dc);
|
|
}
|
|
else {
|
|
render_generic_lib(dc);
|
|
}
|
|
}
|
|
|
|
void AMSLib::render_lite_lib(wxDC& dc)
|
|
{
|
|
wxSize size = GetSize();
|
|
auto libsize = AMS_LITE_CAN_LIB_SIZE;
|
|
ScalableBitmap tray_bitmap, tray_bitmap_hover, tray_bitmap_selected;
|
|
if (m_ams_model == AMSModel::AMS_LITE){
|
|
tray_bitmap = (m_can_index <= 1) ? m_bitmap_extra_tray_left : m_bitmap_extra_tray_right;
|
|
tray_bitmap_hover = (m_can_index <= 1) ? m_bitmap_extra_tray_left_hover : m_bitmap_extra_tray_right_hover;
|
|
tray_bitmap_selected = (m_can_index <= 1) ? m_bitmap_extra_tray_left_selected : m_bitmap_extra_tray_right_selected;
|
|
}
|
|
else{
|
|
tray_bitmap = m_bitmap_extra_tray_mid;
|
|
tray_bitmap_hover = m_bitmap_extra_tray_mid_hover;
|
|
tray_bitmap_selected = m_bitmap_extra_tray_mid_selected;
|
|
}
|
|
|
|
auto tmp_lib_colour = m_info.material_colour;
|
|
change_the_opacity(tmp_lib_colour);
|
|
|
|
auto temp_bitmap_third = m_bitmap_editable_light;
|
|
auto temp_bitmap_brand = m_bitmap_readonly_light;
|
|
|
|
//draw road
|
|
|
|
|
|
dc.SetPen(wxPen(AMS_CONTROL_GRAY500, 2, wxPENSTYLE_SOLID));
|
|
dc.SetBrush(wxBrush(*wxTRANSPARENT_BRUSH));
|
|
|
|
if (m_pass_road) {
|
|
dc.SetPen(wxPen(m_info.material_colour, 4, wxPENSTYLE_SOLID));
|
|
}
|
|
|
|
if (m_can_index == 0 || m_can_index == 3) {
|
|
dc.DrawLine(size.x / 2, size.y / 2, size.x / 2, size.y);
|
|
}
|
|
else {
|
|
dc.DrawLine(size.x / 2, size.y / 2, size.x / 2, 0);
|
|
}
|
|
|
|
//draw def background
|
|
dc.SetPen(wxPen(*wxTRANSPARENT_PEN));
|
|
dc.SetBrush(wxBrush(StateColor::darkModeColorFor(AMS_CONTROL_DEF_LIB_BK_COLOUR)));
|
|
if (m_ams_model == AMSModel::EXT_AMS){
|
|
dc.DrawRoundedRectangle(FromDIP(10), FromDIP(6), libsize.x - FromDIP(20), libsize.y - FromDIP(12), 0);
|
|
}
|
|
dc.DrawRoundedRectangle(FromDIP(10), FromDIP(10), libsize.x - FromDIP(20), libsize.y - FromDIP(20), 0);
|
|
|
|
if (tmp_lib_colour.GetLuminance() < 0.6) {
|
|
temp_bitmap_third = m_bitmap_editable_light;
|
|
temp_bitmap_brand = m_bitmap_readonly_light;
|
|
}
|
|
else {
|
|
temp_bitmap_third = m_bitmap_editable;
|
|
temp_bitmap_brand = m_bitmap_readonly;
|
|
}
|
|
|
|
if (m_info.material_remain < 50) {
|
|
temp_bitmap_third = m_bitmap_editable;
|
|
temp_bitmap_brand = m_bitmap_readonly;
|
|
}
|
|
|
|
if (tmp_lib_colour.Alpha() == 0) {
|
|
temp_bitmap_third = m_bitmap_editable;
|
|
temp_bitmap_brand = m_bitmap_readonly;
|
|
}
|
|
|
|
dc.SetPen(wxPen(*wxTRANSPARENT_PEN));
|
|
if (m_info.material_cols.size() > 1) {
|
|
int left = FromDIP(10);
|
|
int gwidth = std::round(libsize.x / (m_info.material_cols.size() - 1));
|
|
//gradient
|
|
if (m_info.ctype == 0) {
|
|
for (int i = 0; i < m_info.material_cols.size() - 1; i++) {
|
|
auto rect = wxRect(left, FromDIP(10), libsize.x - FromDIP(18), libsize.y - FromDIP(18));
|
|
dc.GradientFillLinear(rect, m_info.material_cols[i], m_info.material_cols[i + 1], wxEAST);
|
|
left += gwidth;
|
|
}
|
|
}
|
|
else {
|
|
int cols_size = m_info.material_cols.size();
|
|
for (int i = 0; i < cols_size; i++) {
|
|
dc.SetBrush(wxBrush(m_info.material_cols[i]));
|
|
float x = FromDIP(10) + ((float)libsize.x - FromDIP(18)) * i / cols_size;
|
|
dc.DrawRoundedRectangle(x, FromDIP(10), ((float)libsize.x - FromDIP(17)) / cols_size, libsize.y - FromDIP(20), 0);
|
|
}
|
|
dc.SetBrush(wxBrush(tmp_lib_colour));
|
|
}
|
|
}
|
|
else {
|
|
dc.SetBrush(wxBrush(tmp_lib_colour));
|
|
if (m_ams_model == AMSModel::EXT_AMS) {
|
|
dc.DrawRoundedRectangle(FromDIP(10), (size.y - libsize.y) / 2 + FromDIP(8), libsize.x - FromDIP(17), libsize.y - FromDIP(16), 0);
|
|
}
|
|
else{
|
|
dc.DrawRoundedRectangle(FromDIP(10), (size.y - libsize.y) / 2 + FromDIP(10), libsize.x - FromDIP(17), libsize.y - FromDIP(20), 0);
|
|
}
|
|
|
|
}
|
|
dc.SetPen(wxPen(*wxTRANSPARENT_PEN));
|
|
dc.SetBrush(wxBrush(tmp_lib_colour));
|
|
if (!m_disable_mode) {
|
|
// edit icon
|
|
if (m_info.material_state != AMSCanType::AMS_CAN_TYPE_EMPTY && m_info.material_state != AMSCanType::AMS_CAN_TYPE_NONE)
|
|
{
|
|
if (m_info.material_state == AMSCanType::AMS_CAN_TYPE_THIRDBRAND || m_info.material_state == AMSCanType::AMS_CAN_TYPE_VIRTUAL)
|
|
dc.DrawBitmap(temp_bitmap_third.bmp(), (size.x - temp_bitmap_third.GetBmpSize().x) / 2 + FromDIP(2), (size.y - FromDIP(18) - temp_bitmap_third.GetBmpSize().y));
|
|
if (m_info.material_state == AMSCanType::AMS_CAN_TYPE_BRAND)
|
|
dc.DrawBitmap(temp_bitmap_brand.bmp(), (size.x - temp_bitmap_brand.GetBmpSize().x) / 2 + FromDIP(2), (size.y - FromDIP(18) - temp_bitmap_brand.GetBmpSize().y));
|
|
}
|
|
}
|
|
|
|
// selected & hover
|
|
if (m_selected) {
|
|
dc.DrawBitmap(tray_bitmap_selected.bmp(), (size.x - tray_bitmap_selected.GetBmpSize().x) / 2, (size.y - tray_bitmap_selected.GetBmpSize().y) / 2);
|
|
}
|
|
else if (!m_selected && m_hover) {
|
|
dc.DrawBitmap(tray_bitmap_hover.bmp(), (size.x - tray_bitmap_hover.GetBmpSize().x) / 2, (size.y - tray_bitmap_hover.GetBmpSize().y) / 2);
|
|
}
|
|
else {
|
|
dc.DrawBitmap(tray_bitmap.bmp(), (size.x - tray_bitmap.GetBmpSize().x) / 2, (size.y - tray_bitmap.GetBmpSize().y) / 2);
|
|
}
|
|
}
|
|
|
|
|
|
void AMSLib::render_generic_lib(wxDC &dc)
|
|
{
|
|
wxSize size = GetSize();
|
|
auto tmp_lib_colour = m_info.material_colour;
|
|
change_the_opacity(tmp_lib_colour);
|
|
|
|
auto temp_bitmap_third = m_bitmap_editable_light;
|
|
auto temp_bitmap_brand = m_bitmap_readonly_light;
|
|
|
|
//draw def background
|
|
dc.SetPen(wxPen(*wxTRANSPARENT_PEN));
|
|
dc.SetBrush(wxBrush(AMS_CONTROL_DEF_LIB_BK_COLOUR));
|
|
dc.DrawRoundedRectangle(FromDIP(2), FromDIP(2), size.x - FromDIP(4), size.y - FromDIP(3), m_radius);
|
|
|
|
if (tmp_lib_colour.GetLuminance() < 0.6) {
|
|
temp_bitmap_third = m_bitmap_editable_light;
|
|
temp_bitmap_brand = m_bitmap_readonly_light;
|
|
}
|
|
else {
|
|
temp_bitmap_third = m_bitmap_editable;
|
|
temp_bitmap_brand = m_bitmap_readonly;
|
|
}
|
|
|
|
if (m_info.material_remain < 50) {
|
|
temp_bitmap_third = m_bitmap_editable;
|
|
temp_bitmap_brand = m_bitmap_readonly;
|
|
}
|
|
|
|
if (tmp_lib_colour.Alpha() == 0) {
|
|
temp_bitmap_third = m_bitmap_editable;
|
|
temp_bitmap_brand = m_bitmap_readonly;
|
|
}
|
|
|
|
dc.SetPen(wxPen(tmp_lib_colour, 1, wxPENSTYLE_SOLID));
|
|
dc.SetBrush(wxBrush(tmp_lib_colour));
|
|
|
|
//draw remain
|
|
auto alpha = m_info.material_colour.Alpha();
|
|
int height = size.y;
|
|
int curr_height = height * float(m_info.material_remain * 1.0 / 100.0);
|
|
dc.SetFont(::Label::Body_13);
|
|
|
|
int top = height - curr_height;
|
|
|
|
if (m_ams_model == EXT_AMS){
|
|
dc.DrawRoundedRectangle(FromDIP(1), FromDIP(1), size.x - FromDIP(2), size.y - FromDIP(1), m_radius - 1);
|
|
if (alpha == 0) {
|
|
dc.DrawBitmap(m_bitmap_transparent_def.bmp(), FromDIP(2), FromDIP(2));
|
|
}
|
|
else if (alpha != 255 && alpha != 254) {
|
|
if (transparent_changed) {
|
|
transparent_changed = false;
|
|
}
|
|
dc.DrawBitmap(m_bitmap_transparent.bmp(), FromDIP(2), FromDIP(2));
|
|
}
|
|
|
|
if (!m_disable_mode) {
|
|
// edit icon
|
|
if (m_info.material_state != AMSCanType::AMS_CAN_TYPE_EMPTY && m_info.material_state != AMSCanType::AMS_CAN_TYPE_NONE) {
|
|
if (m_info.material_state == AMSCanType::AMS_CAN_TYPE_THIRDBRAND || m_info.material_state == AMSCanType::AMS_CAN_TYPE_VIRTUAL)
|
|
dc.DrawBitmap(temp_bitmap_third.bmp(), (size.x - temp_bitmap_third.GetBmpSize().x) / 2, (size.y - FromDIP(10) - temp_bitmap_third.GetBmpSize().y));
|
|
if (m_info.material_state == AMSCanType::AMS_CAN_TYPE_BRAND)
|
|
dc.DrawBitmap(temp_bitmap_brand.bmp(), (size.x - temp_bitmap_brand.GetBmpSize().x) / 2, (size.y - FromDIP(10) - temp_bitmap_brand.GetBmpSize().y));
|
|
}
|
|
}
|
|
|
|
dc.SetPen(wxPen(wxColour(130, 130, 128), 1, wxPENSTYLE_SOLID));
|
|
dc.SetBrush(wxBrush(*wxTRANSPARENT_BRUSH));
|
|
#ifdef __APPLE__
|
|
dc.DrawRoundedRectangle(FromDIP(1), FromDIP(1), size.x - FromDIP(2), size.y - FromDIP(1), m_radius);
|
|
#else
|
|
dc.DrawRoundedRectangle(FromDIP(1), FromDIP(1), size.x - FromDIP(2), size.y - FromDIP(1), m_radius);
|
|
#endif
|
|
if (m_selected) {
|
|
dc.SetPen(wxPen(AMS_CONTROL_BRAND_COLOUR, 3, wxPENSTYLE_SOLID));
|
|
//dc.SetPen(wxPen(tmp_lib_colour, 2, wxPENSTYLE_SOLID));
|
|
if (tmp_lib_colour.Alpha() == 0) {
|
|
dc.SetPen(wxPen(wxColour(tmp_lib_colour.Red(), tmp_lib_colour.Green(), tmp_lib_colour.Blue(), 128), 3, wxPENSTYLE_SOLID));
|
|
}
|
|
dc.SetBrush(wxBrush(*wxTRANSPARENT_BRUSH));
|
|
#ifdef __APPLE__
|
|
dc.DrawRoundedRectangle(FromDIP(1), FromDIP(1), size.x - FromDIP(2), size.y - FromDIP(2), 0);
|
|
#else
|
|
dc.DrawRoundedRectangle(0, 0, size.x, size.y, m_radius);
|
|
#endif
|
|
|
|
dc.SetPen(wxPen(*wxTRANSPARENT_PEN));
|
|
dc.SetBrush(wxBrush(tmp_lib_colour));
|
|
}
|
|
|
|
if (!m_selected && m_hover) {
|
|
dc.SetPen(wxPen(AMS_CONTROL_BRAND_COLOUR, 3, wxPENSTYLE_SOLID));
|
|
dc.SetBrush(wxBrush(*wxTRANSPARENT_BRUSH));
|
|
#ifdef __APPLE__
|
|
dc.DrawRoundedRectangle(FromDIP(1), FromDIP(1), size.x - FromDIP(2), size.y - FromDIP(2), 0);
|
|
#else
|
|
dc.DrawRoundedRectangle(0, 0, size.x, size.y, m_radius);
|
|
#endif
|
|
dc.SetPen(wxPen(*wxTRANSPARENT_PEN));
|
|
dc.SetBrush(wxBrush(tmp_lib_colour));
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (curr_height >= FromDIP(1)) {
|
|
|
|
//transparent
|
|
if (alpha == 0) {
|
|
dc.DrawBitmap(m_bitmap_transparent_def.bmp(), FromDIP(2), FromDIP(2));
|
|
}
|
|
else if (alpha != 255 && alpha != 254) {
|
|
if (transparent_changed) {
|
|
std::string rgb = (tmp_lib_colour.GetAsString(wxC2S_HTML_SYNTAX)).ToStdString();
|
|
if (rgb.size() == 9) {
|
|
//delete alpha value
|
|
rgb = rgb.substr(0, rgb.size() - 2);
|
|
}
|
|
float alpha_f = 0.7 * tmp_lib_colour.Alpha() / 255.0;
|
|
std::vector<std::string> replace;
|
|
replace.push_back(rgb);
|
|
std::string fill_replace = "fill-opacity=\"" + std::to_string(alpha_f);
|
|
replace.push_back(fill_replace);
|
|
m_bitmap_transparent = ScalableBitmap(this, "transparent_ams_lib", 76, false, false, true, replace);
|
|
transparent_changed = false;
|
|
|
|
}
|
|
dc.DrawBitmap(m_bitmap_transparent.bmp(), FromDIP(2), FromDIP(2));
|
|
}
|
|
//gradient
|
|
if (m_info.material_cols.size() > 1) {
|
|
auto left = FromDIP(2);
|
|
float total_width = size.x - FromDIP(4);
|
|
int gwidth = std::round(total_width / (m_info.material_cols.size() - 1));
|
|
//gradient
|
|
if (m_info.ctype == 0) {
|
|
for (int i = 0; i < m_info.material_cols.size() - 1; i++) {
|
|
|
|
if ((left + gwidth) > (size.x)) {
|
|
gwidth = (size.x) - left;
|
|
}
|
|
|
|
auto rect = wxRect(left, height - curr_height, gwidth, curr_height);
|
|
dc.GradientFillLinear(rect, m_info.material_cols[i], m_info.material_cols[i + 1], wxEAST);
|
|
left += gwidth;
|
|
}
|
|
}
|
|
else {
|
|
//multicolour
|
|
gwidth = std::round(total_width / m_info.material_cols.size());
|
|
for (int i = 0; i < m_info.material_cols.size(); i++) {
|
|
dc.SetPen(wxPen(*wxTRANSPARENT_PEN));
|
|
dc.SetBrush(wxBrush(m_info.material_cols[i]));
|
|
if (i == 0 || i == m_info.material_cols.size() - 1) {
|
|
#ifdef __APPLE__
|
|
dc.DrawRoundedRectangle(left + gwidth * i - FromDIP(1), height - curr_height, gwidth, curr_height, m_radius);
|
|
#else
|
|
dc.DrawRoundedRectangle(left + gwidth * i, height - curr_height, gwidth, curr_height, m_radius - 1);
|
|
#endif
|
|
//add rectangle
|
|
int dr_gwidth = std::round(gwidth * 0.6);
|
|
if (i == 0) {
|
|
dc.DrawRectangle(left + gwidth - dr_gwidth, height - curr_height, dr_gwidth, curr_height);
|
|
}
|
|
else {
|
|
dc.DrawRectangle(left + gwidth*i, height - curr_height, dr_gwidth, curr_height);
|
|
}
|
|
}
|
|
else {
|
|
dc.DrawRectangle(left + gwidth * i, height - curr_height, gwidth, curr_height);
|
|
}
|
|
}
|
|
//reset pen and brush
|
|
if (m_selected || m_hover) {
|
|
dc.SetPen(wxPen(*wxTRANSPARENT_PEN));
|
|
dc.SetBrush(wxBrush(tmp_lib_colour));
|
|
}
|
|
else {
|
|
dc.SetPen(wxPen(tmp_lib_colour, 1, wxPENSTYLE_SOLID));
|
|
dc.SetBrush(wxBrush(tmp_lib_colour));
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
auto brush = dc.GetBrush();
|
|
if (alpha != 0 && alpha != 255 && alpha != 254) dc.SetBrush(wxBrush(*wxTRANSPARENT_BRUSH));
|
|
#ifdef __APPLE__
|
|
dc.DrawRoundedRectangle(FromDIP(1), FromDIP(1), size.x - FromDIP(2), size.y - FromDIP(1), m_radius - 1);
|
|
#else
|
|
dc.DrawRoundedRectangle(FromDIP(2), FromDIP(1) + top, size.x - FromDIP(4), curr_height, m_radius - 1);
|
|
#endif
|
|
dc.SetBrush(brush);
|
|
}
|
|
}
|
|
|
|
if (top > 2) {
|
|
if (curr_height >= FromDIP(1)) {
|
|
//dc.DrawLine(FromDIP(2), top, size.x - FromDIP(4), top);
|
|
if (alpha != 255 && alpha != 254) {
|
|
dc.SetPen(wxPen(*wxWHITE));
|
|
dc.SetBrush(wxBrush(*wxWHITE));
|
|
#ifdef __APPLE__
|
|
dc.DrawRoundedRectangle(FromDIP(2), FromDIP(1) , size.x - FromDIP(4), top, m_radius);
|
|
#else
|
|
dc.DrawRoundedRectangle(FromDIP(2), FromDIP(1) , size.x - FromDIP(4), top, m_radius - 1);
|
|
#endif
|
|
}
|
|
if (tmp_lib_colour.Red() > 238 && tmp_lib_colour.Green() > 238 && tmp_lib_colour.Blue() > 238) {
|
|
dc.SetPen(wxPen(wxColour(130, 129, 128), 1, wxPENSTYLE_SOLID));
|
|
dc.SetBrush(wxBrush(*wxTRANSPARENT_BRUSH));
|
|
if (m_info.material_cols.size() <= 1){
|
|
dc.DrawLine(FromDIP(2), top, size.x - FromDIP(4), top);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
dc.SetBrush(wxBrush(*wxTRANSPARENT_BRUSH));
|
|
if (tmp_lib_colour.Red() > 238 && tmp_lib_colour.Green() > 238 && tmp_lib_colour.Blue() > 238) {
|
|
dc.SetPen(wxPen(wxColour(130, 129, 128), 2, wxPENSTYLE_SOLID));
|
|
}
|
|
else {
|
|
dc.SetPen(wxPen(tmp_lib_colour, 2, wxPENSTYLE_SOLID));
|
|
}
|
|
|
|
#ifdef __APPLE__
|
|
dc.DrawLine(FromDIP(5), FromDIP(4) + height - FromDIP(2), size.x - FromDIP(5), FromDIP(4) + height - FromDIP(2));
|
|
dc.DrawLine(FromDIP(6), FromDIP(4) + height - FromDIP(1), size.x - FromDIP(6), FromDIP(4) + height - FromDIP(1));
|
|
#else
|
|
//dc.DrawLine(FromDIP(2), FromDIP(0 + height), FromDIP(size.x - 4), FromDIP(height));
|
|
dc.DrawLine(FromDIP(2), height - FromDIP(1), size.x - FromDIP(4), height - FromDIP(1));
|
|
#endif
|
|
}
|
|
}
|
|
|
|
//border
|
|
dc.SetPen(wxPen(wxColour(130, 130, 128), 1, wxPENSTYLE_SOLID));
|
|
dc.SetBrush(wxBrush(*wxTRANSPARENT_BRUSH));
|
|
#ifdef __APPLE__
|
|
dc.DrawRoundedRectangle(FromDIP(1), FromDIP(1), size.x - FromDIP(2), size.y - FromDIP(1), m_radius);
|
|
#else
|
|
dc.DrawRoundedRectangle(FromDIP(1), FromDIP(1), size.x - FromDIP(2), size.y - FromDIP(1), m_radius);
|
|
#endif
|
|
|
|
if (m_selected) {
|
|
dc.SetPen(wxPen(AMS_CONTROL_BRAND_COLOUR, 3, wxPENSTYLE_SOLID));
|
|
//dc.SetPen(wxPen(tmp_lib_colour, 3, wxPENSTYLE_SOLID));
|
|
if (tmp_lib_colour.Alpha() == 0) {
|
|
dc.SetPen(wxPen(wxColour(tmp_lib_colour.Red(), tmp_lib_colour.Green(), tmp_lib_colour.Blue(), 128), 3, wxPENSTYLE_SOLID));
|
|
}
|
|
dc.SetBrush(wxBrush(*wxTRANSPARENT_BRUSH));
|
|
#ifdef __APPLE__
|
|
dc.DrawRoundedRectangle(FromDIP(1), FromDIP(1), size.x - FromDIP(2), size.y - FromDIP(2), 0);
|
|
#else
|
|
dc.DrawRoundedRectangle(0, 0, size.x, size.y, m_radius);
|
|
#endif
|
|
dc.SetPen(wxPen(*wxTRANSPARENT_PEN));
|
|
dc.SetBrush(wxBrush(tmp_lib_colour));
|
|
}
|
|
|
|
if (!m_selected && m_hover) {
|
|
dc.SetPen(wxPen(AMS_CONTROL_BRAND_COLOUR, 3, wxPENSTYLE_SOLID));
|
|
dc.SetBrush(wxBrush(*wxTRANSPARENT_BRUSH));
|
|
#ifdef __APPLE__
|
|
dc.DrawRoundedRectangle(FromDIP(1), FromDIP(1), size.x - FromDIP(2), size.y - FromDIP(2), 0);
|
|
#else
|
|
dc.DrawRoundedRectangle(0, 0, size.x, size.y, m_radius);
|
|
#endif
|
|
dc.SetPen(wxPen(*wxTRANSPARENT_PEN));
|
|
dc.SetBrush(wxBrush(tmp_lib_colour));
|
|
}
|
|
|
|
if (!m_disable_mode) {
|
|
// edit icon
|
|
if (m_info.material_state != AMSCanType::AMS_CAN_TYPE_EMPTY && m_info.material_state != AMSCanType::AMS_CAN_TYPE_NONE)
|
|
{
|
|
if (m_info.material_state == AMSCanType::AMS_CAN_TYPE_THIRDBRAND || m_info.material_state == AMSCanType::AMS_CAN_TYPE_VIRTUAL)
|
|
dc.DrawBitmap(temp_bitmap_third.bmp(), (size.x - temp_bitmap_third.GetBmpSize().x) / 2, (size.y - FromDIP(10) - temp_bitmap_third.GetBmpSize().y));
|
|
if (m_info.material_state == AMSCanType::AMS_CAN_TYPE_BRAND)
|
|
dc.DrawBitmap(temp_bitmap_brand.bmp(), (size.x - temp_bitmap_brand.GetBmpSize().x) / 2, (size.y - FromDIP(10) - temp_bitmap_brand.GetBmpSize().y));
|
|
}
|
|
}
|
|
}
|
|
|
|
void AMSLib::on_pass_road(bool pass)
|
|
{
|
|
if (m_pass_road != pass) {
|
|
m_pass_road = pass;
|
|
Refresh();
|
|
}
|
|
}
|
|
|
|
void AMSLib::Update(Caninfo info, std::string ams_idx, bool refresh)
|
|
{
|
|
DeviceManager* dev = Slic3r::GUI::wxGetApp().getDeviceManager();
|
|
if (!dev) return;
|
|
if (dev->get_selected_machine() && dev->get_selected_machine() != m_obj) {
|
|
m_obj = dev->get_selected_machine();
|
|
}
|
|
if (info.material_colour.Alpha() != 0 && info.material_colour.Alpha() != 255 && info.material_colour.Alpha() != 254 && m_info.material_colour != info.material_colour) {
|
|
transparent_changed = true;
|
|
}
|
|
|
|
m_info = info;
|
|
m_ams_id = ams_idx;
|
|
m_slot_id = info.can_id;
|
|
if (refresh) Refresh();
|
|
}
|
|
|
|
wxColour AMSLib::GetLibColour() { return m_info.material_colour; }
|
|
|
|
void AMSLib::OnSelected()
|
|
{
|
|
if (!wxWindow::IsEnabled()) return;
|
|
if (m_unable_selected) return;
|
|
|
|
post_event(wxCommandEvent(EVT_AMS_ON_SELECTED));
|
|
m_selected = true;
|
|
Refresh();
|
|
}
|
|
|
|
void AMSLib::post_event(wxCommandEvent &&event)
|
|
{
|
|
//int tray_id = atoi(m_ams_id.c_str()) * 4 + atoi(m_info.can_id.c_str());
|
|
//event.SetString(m_info.can_id);
|
|
event.SetString(m_slot_id);
|
|
event.SetInt(std::stoi(m_ams_id));
|
|
event.SetEventObject(m_parent);
|
|
wxPostEvent(m_parent, event);
|
|
event.Skip();
|
|
}
|
|
|
|
void AMSLib::UnSelected()
|
|
{
|
|
m_selected = false;
|
|
Refresh();
|
|
}
|
|
|
|
bool AMSLib::Enable(bool enable) { return wxWindow::Enable(enable); }
|
|
|
|
void AMSLib::msw_rescale()
|
|
{
|
|
//m_bitmap_transparent.msw_rescale();
|
|
m_bitmap_transparent_def.msw_rescale();
|
|
m_bitmap_editable = ScalableBitmap(this, "ams_editable", 14);
|
|
m_bitmap_editable_light = ScalableBitmap(this, "ams_editable_light", 14);
|
|
m_bitmap_readonly = ScalableBitmap(this, "ams_readonly", 14);
|
|
m_bitmap_readonly_light = ScalableBitmap(this, "ams_readonly_light", 14);
|
|
m_bitmap_transparent = ScalableBitmap(this, "transparent_ams_lib", 76);
|
|
m_bitmap_transparent_def = ScalableBitmap(this, "transparent_ams_lib", 76);
|
|
|
|
m_bitmap_extra_tray_left = ScalableBitmap(this, "extra_ams_tray_left", 72);
|
|
m_bitmap_extra_tray_right = ScalableBitmap(this, "extra_ams_tray_right", 72);
|
|
m_bitmap_extra_tray_mid = ScalableBitmap(this, "extra_ams_tray_mid", 72);
|
|
|
|
m_bitmap_extra_tray_left_hover = ScalableBitmap(this, "extra_ams_tray_left_hover", 72);
|
|
m_bitmap_extra_tray_right_hover = ScalableBitmap(this, "extra_ams_tray_right_hover", 72);
|
|
m_bitmap_extra_tray_mid_hover = ScalableBitmap(this, "extra_ams_tray_mid_hover", 72);
|
|
|
|
m_bitmap_extra_tray_left_selected = ScalableBitmap(this, "extra_ams_tray_left_selected", 72);
|
|
m_bitmap_extra_tray_right_selected = ScalableBitmap(this, "extra_ams_tray_right_selected", 72);
|
|
m_bitmap_extra_tray_mid_selected = ScalableBitmap(this, "extra_ams_tray_mid_selected", 72);
|
|
|
|
Layout();
|
|
Refresh();
|
|
}
|
|
|
|
/*************************************************
|
|
Description:AMSRoad
|
|
**************************************************/
|
|
AMSRoad::AMSRoad() : m_road_def_color(AMS_CONTROL_GRAY500), m_road_color(AMS_CONTROL_GRAY500) {}
|
|
AMSRoad::AMSRoad(wxWindow *parent, wxWindowID id, Caninfo info, int canindex, int maxcan, const wxPoint &pos, const wxSize &size)
|
|
: AMSRoad()
|
|
{
|
|
m_info = info;
|
|
m_canindex = canindex;
|
|
// road type
|
|
auto mode = AMSRoadMode::AMS_ROAD_MODE_END;
|
|
if (m_canindex == 0 && maxcan == 1) {
|
|
m_rode_mode = AMSRoadMode::AMS_ROAD_MODE_NONE;
|
|
} else if (m_canindex == 0 && maxcan > 1) {
|
|
m_rode_mode = AMSRoadMode::AMS_ROAD_MODE_END;
|
|
} else if (m_canindex < (maxcan - 1)) {
|
|
m_rode_mode = AMSRoadMode::AMS_ROAD_MODE_LEFT_RIGHT;
|
|
} else if (m_canindex == (maxcan - 1)) {
|
|
m_rode_mode = AMSRoadMode::AMS_ROAD_MODE_LEFT;
|
|
} else if (m_canindex == -1 && maxcan == -1) {
|
|
m_rode_mode = AMSRoadMode::AMS_ROAD_MODE_VIRTUAL_TRAY;
|
|
}
|
|
else {
|
|
m_rode_mode = AMSRoadMode::AMS_ROAD_MODE_NONE_ANY_ROAD;
|
|
}
|
|
|
|
for (int i = 1; i <= 5; i++) {
|
|
ams_humidity_img.push_back(ScalableBitmap(this, "hum_level" + std::to_string(i) + "_light", 32));
|
|
}
|
|
|
|
for (int i = 1; i <= 5; i++) {
|
|
ams_humidity_img.push_back(ScalableBitmap(this, "hum_level" + std::to_string(i) + "_dark", 32));
|
|
}
|
|
if (m_rode_mode != AMSRoadMode::AMS_ROAD_MODE_VIRTUAL_TRAY) {
|
|
create(parent, id, pos, size);
|
|
}
|
|
else {
|
|
wxSize virtual_size(size.x - 1, size.y + 2);
|
|
create(parent, id, pos, virtual_size);
|
|
|
|
}
|
|
|
|
Bind(wxEVT_PAINT, &AMSRoad::paintEvent, this);
|
|
wxWindow::SetBackgroundColour(AMS_CONTROL_DEF_BLOCK_BK_COLOUR);
|
|
|
|
Bind(wxEVT_LEFT_UP, [this](wxMouseEvent& e) {
|
|
if (m_canindex == 3 && m_show_humidity) {
|
|
auto mouse_pos = ClientToScreen(e.GetPosition());
|
|
auto rect = ClientToScreen(wxPoint(0, 0));
|
|
|
|
if (mouse_pos.x > rect.x + GetSize().x - FromDIP(40) &&
|
|
mouse_pos.y > rect.y + GetSize().y - FromDIP(40)) {
|
|
wxCommandEvent show_event(EVT_AMS_SHOW_HUMIDITY_TIPS);
|
|
wxPostEvent(GetParent()->GetParent(), show_event);
|
|
|
|
#ifdef __WXMSW__
|
|
wxCommandEvent close_event(EVT_CLEAR_SPEED_CONTROL);
|
|
wxPostEvent(GetParent()->GetParent(), close_event);
|
|
#endif // __WXMSW__
|
|
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
void AMSRoad::create(wxWindow *parent, wxWindowID id, const wxPoint &pos, const wxSize &size) { wxWindow::Create(parent, id, pos, size); }
|
|
|
|
void AMSRoad::Update(AMSinfo amsinfo, Caninfo info, int canindex, int maxcan)
|
|
{
|
|
m_amsinfo = amsinfo;
|
|
m_info = info;
|
|
m_canindex = canindex;
|
|
if (m_canindex == 0 && maxcan == 1) {
|
|
m_rode_mode = AMSRoadMode::AMS_ROAD_MODE_END_ONLY;
|
|
} else if (m_canindex == 0 && maxcan > 1) {
|
|
m_rode_mode = AMSRoadMode::AMS_ROAD_MODE_END;
|
|
} else if (m_canindex < (maxcan - 1)) {
|
|
m_rode_mode = AMSRoadMode::AMS_ROAD_MODE_LEFT_RIGHT;
|
|
} else if (m_canindex == (maxcan - 1)) {
|
|
m_rode_mode = AMSRoadMode::AMS_ROAD_MODE_LEFT;
|
|
}
|
|
m_pass_rode_mode.push_back(AMSPassRoadMode::AMS_ROAD_MODE_NONE);
|
|
Refresh();
|
|
}
|
|
|
|
void AMSRoad::OnVamsLoading(bool load, wxColour col /*= AMS_CONTROL_GRAY500*/)
|
|
{
|
|
/*m_vams_loading = load;
|
|
if(load)m_road_color = col;
|
|
Refresh();*/
|
|
}
|
|
|
|
void AMSRoad::SetPassRoadColour(wxColour col) { m_road_color = col; }
|
|
|
|
void AMSRoad::SetMode(AMSRoadMode mode)
|
|
{
|
|
m_rode_mode = mode;
|
|
Refresh();
|
|
}
|
|
|
|
void AMSRoad::paintEvent(wxPaintEvent &evt)
|
|
{
|
|
wxPaintDC dc(this);
|
|
render(dc);
|
|
}
|
|
|
|
void AMSRoad::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 AMSRoad::doRender(wxDC &dc)
|
|
{
|
|
wxSize size = GetSize();
|
|
|
|
dc.SetPen(wxPen(m_road_def_color, 2, wxPENSTYLE_SOLID));
|
|
dc.SetBrush(wxBrush(*wxTRANSPARENT_BRUSH));
|
|
// left mode
|
|
if (m_rode_mode == AMSRoadMode::AMS_ROAD_MODE_LEFT) { dc.DrawRoundedRectangle(-10, -10, size.x / 2 + 10, size.y * 0.6 + 10, 4); }
|
|
|
|
// left right mode
|
|
if (m_rode_mode == AMSRoadMode::AMS_ROAD_MODE_LEFT_RIGHT) {
|
|
dc.DrawLine(size.x / 2, 0, size.x / 2, size.y * 0.6 - FromDIP(1));
|
|
dc.DrawLine(0, size.y * 0.6 - 1, size.x, size.y * 0.6 - FromDIP(1));
|
|
}
|
|
|
|
// end mode
|
|
if (m_rode_mode == AMSRoadMode::AMS_ROAD_MODE_END) {
|
|
dc.SetBrush(wxBrush(m_road_def_color));
|
|
dc.DrawLine(size.x / 2, -1, size.x / 2, size.y * 0.6 - 1);
|
|
dc.DrawLine(size.x / 2, size.y * 0.6, size.x / 2, size.y);
|
|
dc.DrawLine(size.x / 2, size.y * 0.6 - 1, size.x, size.y * 0.6 - 1);
|
|
}
|
|
|
|
// end mode only
|
|
if (m_rode_mode == AMSRoadMode::AMS_ROAD_MODE_END_ONLY) {
|
|
dc.SetBrush(wxBrush(m_road_def_color));
|
|
dc.DrawLine(size.x / 2, -1, size.x / 2, size.y * 0.6 - 1);
|
|
dc.DrawLine(size.x / 2, size.y * 0.6, size.x / 2, size.y);
|
|
}
|
|
|
|
// end none
|
|
if (m_rode_mode == AMSRoadMode::AMS_ROAD_MODE_NONE) {
|
|
dc.SetBrush(wxBrush(m_road_def_color));
|
|
dc.DrawLine(size.x / 2, -1, size.x / 2, size.y * 0.6 - 1);
|
|
dc.DrawLine(size.x / 2, size.y * 0.6, size.x / 2, size.y);
|
|
// dc.DrawLine(size.x / 2, size.y * 0.6 - 1, size.x, size.y * 0.6 - 1);
|
|
}
|
|
|
|
//virtual road
|
|
if (m_rode_mode == AMSRoadMode::AMS_ROAD_MODE_VIRTUAL_TRAY) {
|
|
dc.SetBrush(wxBrush(m_road_def_color));
|
|
dc.DrawLine(size.x / 2, -1, size.x / 2, size.y - 1);
|
|
}
|
|
|
|
// mode none
|
|
// if (m_pass_rode_mode.size() == 1 && m_pass_rode_mode[0] == AMSPassRoadMode::AMS_ROAD_MODE_NONE) return;
|
|
|
|
if (m_road_color.Alpha() == 0) {dc.SetPen(wxPen(*wxWHITE, m_passroad_width, wxPENSTYLE_SOLID));}
|
|
else {dc.SetPen(wxPen(m_road_color, m_passroad_width, wxPENSTYLE_SOLID));}
|
|
|
|
dc.SetBrush(wxBrush(*wxTRANSPARENT_BRUSH));
|
|
|
|
// left pass mode
|
|
for (auto pass_mode : m_pass_rode_mode) {
|
|
switch (pass_mode) {
|
|
case AMSPassRoadMode::AMS_ROAD_MODE_LEFT: dc.DrawRoundedRectangle(-10, -10, size.x / 2 + 10, size.y * 0.6 + 10, 4); break;
|
|
|
|
case AMSPassRoadMode::AMS_ROAD_MODE_LEFT_RIGHT: dc.DrawLine(0, size.y * 0.6 - 1, size.x, size.y * 0.6 - 1); break;
|
|
|
|
case AMSPassRoadMode::AMS_ROAD_MODE_END_TOP: dc.DrawLine(size.x / 2, -1, size.x / 2, size.y * 0.6 - 1); break;
|
|
|
|
case AMSPassRoadMode::AMS_ROAD_MODE_END_BOTTOM: dc.DrawLine(size.x / 2, size.y * 0.6, size.x / 2, size.y); break;
|
|
|
|
case AMSPassRoadMode::AMS_ROAD_MODE_END_RIGHT: dc.DrawLine(size.x / 2, size.y * 0.6 - 1, size.x, size.y * 0.6 - 1); break;
|
|
|
|
default: break;
|
|
}
|
|
}
|
|
|
|
if (m_rode_mode == AMSRoadMode::AMS_ROAD_MODE_VIRTUAL_TRAY && m_vams_loading) {
|
|
dc.DrawLine(size.x / 2, -1, size.x / 2, size.y - 1);
|
|
}
|
|
|
|
// end mode
|
|
if (m_rode_mode == AMSRoadMode::AMS_ROAD_MODE_END || m_rode_mode == AMSRoadMode::AMS_ROAD_MODE_END_ONLY) {
|
|
dc.SetPen(wxPen(m_road_def_color, 2, wxPENSTYLE_SOLID));
|
|
dc.SetBrush(wxBrush(m_road_def_color));
|
|
dc.DrawRoundedRectangle(size.x * 0.37 / 2, size.y * 0.6 - size.y / 6, size.x * 0.63, size.y / 3, m_radius);
|
|
}
|
|
|
|
if (m_canindex == 3) {
|
|
|
|
if (m_amsinfo.ams_humidity >= 1 && m_amsinfo.ams_humidity <= 5) {m_show_humidity = true;}
|
|
else {m_show_humidity = false;}
|
|
|
|
if (m_amsinfo.ams_humidity >= 1 && m_amsinfo.ams_humidity <= 5) {
|
|
|
|
int hum_index = m_amsinfo.ams_humidity - 1;
|
|
if (wxGetApp().dark_mode()) {
|
|
hum_index += 5;
|
|
}
|
|
|
|
if (hum_index >= 0) {
|
|
dc.DrawBitmap(ams_humidity_img[hum_index].bmp(), wxPoint(size.x - FromDIP(33), size.y - FromDIP(33)));
|
|
}
|
|
}
|
|
else {
|
|
//to do ...
|
|
}
|
|
}
|
|
}
|
|
|
|
void AMSRoad::UpdatePassRoad(int tag_index, AMSPassRoadType type, AMSPassRoadSTEP step) {}
|
|
|
|
void AMSRoad::OnPassRoad(std::vector<AMSPassRoadMode> prord_list)
|
|
{
|
|
// AMS_ROAD_MODE_NONE, AMS_ROAD_MODE_LEFT, AMS_ROAD_MODE_LEFT_RIGHT, AMS_ROAD_MODE_END_TOP, AMS_ROAD_MODE_END_BOTTOM, AMS_ROAD_MODE_END_RIGHT,
|
|
// AMS_ROAD_MODE_LEFT, AMS_ROAD_MODE_LEFT_RIGHT, AMS_ROAD_MODE_END,
|
|
|
|
m_pass_rode_mode.clear();
|
|
auto left_types = std::vector<AMSPassRoadMode>{AMSPassRoadMode::AMS_ROAD_MODE_NONE, AMSPassRoadMode::AMS_ROAD_MODE_LEFT};
|
|
auto left_right_types = std::vector<AMSPassRoadMode>{AMSPassRoadMode::AMS_ROAD_MODE_NONE, AMSPassRoadMode::AMS_ROAD_MODE_LEFT, AMSPassRoadMode::AMS_ROAD_MODE_LEFT_RIGHT};
|
|
auto end_types = std::vector<AMSPassRoadMode>{AMSPassRoadMode::AMS_ROAD_MODE_NONE, AMSPassRoadMode::AMS_ROAD_MODE_END_TOP, AMSPassRoadMode::AMS_ROAD_MODE_END_BOTTOM,
|
|
AMSPassRoadMode::AMS_ROAD_MODE_END_RIGHT};
|
|
|
|
// left
|
|
if (m_rode_mode == AMSRoadMode::AMS_ROAD_MODE_LEFT) {
|
|
for (auto i = 0; i < prord_list.size(); i++) {
|
|
std::vector<AMSPassRoadMode>::iterator iter = std::find(left_types.begin(), left_types.end(), prord_list[i]);
|
|
if (iter != left_types.end()) m_pass_rode_mode.push_back(prord_list[i]);
|
|
|
|
if (prord_list[i] == AMSPassRoadMode::AMS_ROAD_MODE_NONE) {
|
|
m_pass_rode_mode = std::vector<AMSPassRoadMode>{AMSPassRoadMode::AMS_ROAD_MODE_NONE};
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// left right
|
|
if (m_rode_mode == AMSRoadMode::AMS_ROAD_MODE_LEFT_RIGHT) {
|
|
for (auto i = 0; i < prord_list.size(); i++) {
|
|
std::vector<AMSPassRoadMode>::iterator iter = std::find(left_right_types.begin(), left_right_types.end(), prord_list[i]);
|
|
if (iter != left_right_types.end()) m_pass_rode_mode.push_back(prord_list[i]);
|
|
|
|
if (prord_list[i] == AMSPassRoadMode::AMS_ROAD_MODE_NONE) {
|
|
m_pass_rode_mode = std::vector<AMSPassRoadMode>{AMSPassRoadMode::AMS_ROAD_MODE_NONE};
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// left end
|
|
if (m_rode_mode == AMSRoadMode::AMS_ROAD_MODE_END || m_rode_mode == AMSRoadMode::AMS_ROAD_MODE_END_ONLY) {
|
|
for (auto i = 0; i < prord_list.size(); i++) {
|
|
std::vector<AMSPassRoadMode>::iterator iter = std::find(end_types.begin(), end_types.end(), prord_list[i]);
|
|
if (iter != end_types.end()) m_pass_rode_mode.push_back(prord_list[i]);
|
|
|
|
if (prord_list[i] == AMSPassRoadMode::AMS_ROAD_MODE_NONE) {
|
|
m_pass_rode_mode = std::vector<AMSPassRoadMode>{AMSPassRoadMode::AMS_ROAD_MODE_NONE};
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
|
|
|
|
/*************************************************
|
|
Description:AMSRoadUpPart
|
|
**************************************************/
|
|
AMSRoadUpPart::AMSRoadUpPart() : m_road_def_color(AMS_CONTROL_GRAY500), m_road_color(AMS_CONTROL_GRAY500) {}
|
|
AMSRoadUpPart::AMSRoadUpPart(wxWindow* parent, wxWindowID id, AMSinfo info, AMSModel model, const wxPoint& pos, const wxSize& size)
|
|
: AMSRoadUpPart()
|
|
{
|
|
m_amsinfo = info;
|
|
// road type
|
|
auto mode = AMSRoadMode::AMS_ROAD_MODE_END;
|
|
m_ams_model = model;
|
|
|
|
if (m_ams_model == AMSModel::GENERIC_AMS){
|
|
create(parent, id, pos, wxSize(FromDIP(264), FromDIP(34)));
|
|
}
|
|
else{
|
|
create(parent, id, pos, wxSize(FromDIP(78), FromDIP(34)));
|
|
}
|
|
/*create(parent, id, pos, size);
|
|
this->SetMinSize(AMS_SINGLE_CAN_SIZE);
|
|
this->SetSize(AMS_SINGLE_CAN_SIZE);*/
|
|
|
|
|
|
Bind(wxEVT_PAINT, &AMSRoadUpPart::paintEvent, this);
|
|
wxWindow::SetBackgroundColour(StateColor::darkModeColorFor(AMS_CONTROL_DEF_LIB_BK_COLOUR));
|
|
|
|
}
|
|
|
|
void AMSRoadUpPart::create(wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size) {
|
|
wxWindow::Create(parent, id, pos, size);
|
|
SetSize(size);
|
|
SetMinSize(size);
|
|
SetBackgroundColour(AMS_CONTROL_WHITE_COLOUR);
|
|
Layout();
|
|
Fit();
|
|
Refresh();
|
|
}
|
|
|
|
void AMSRoadUpPart::Update(AMSinfo amsinfo)
|
|
{
|
|
if (m_amsinfo != amsinfo)
|
|
{
|
|
m_amsinfo = amsinfo;
|
|
Refresh();
|
|
}
|
|
}
|
|
|
|
void AMSRoadUpPart::OnVamsLoading(bool load, wxColour col /*= AMS_CONTROL_GRAY500*/)
|
|
{
|
|
/*m_vams_loading = load;
|
|
if(load)m_road_color = col;
|
|
Refresh();*/
|
|
}
|
|
|
|
void AMSRoadUpPart::SetPassRoadColour(wxColour col)
|
|
{
|
|
if (m_road_color != col)
|
|
{
|
|
m_road_color = col;
|
|
Refresh();
|
|
}
|
|
}
|
|
|
|
void AMSRoadUpPart::SetMode(AMSRoadShowMode mode)
|
|
{
|
|
if (m_road_mode != mode)
|
|
{
|
|
m_road_mode = mode;
|
|
Refresh();
|
|
}
|
|
}
|
|
|
|
void AMSRoadUpPart::paintEvent(wxPaintEvent& evt)
|
|
{
|
|
wxPaintDC dc(this);
|
|
render(dc);
|
|
}
|
|
|
|
static wxColour _get_diff_clr(wxWindow *win, wxColour pen_clr) /*STUDIO-10093 get diff color*/
|
|
{
|
|
if (!wxGetApp().dark_mode())
|
|
{
|
|
if (pen_clr.GetRGB() == wxWHITE->GetRGB())
|
|
{
|
|
static int default_distance = 20;
|
|
pen_clr.Set(pen_clr.Red() - default_distance, pen_clr.Green() - default_distance, pen_clr.Blue() - default_distance);
|
|
}
|
|
}
|
|
|
|
return pen_clr;
|
|
}
|
|
|
|
void AMSRoadUpPart::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 AMSRoadUpPart::doRender(wxDC& dc)
|
|
{
|
|
wxSize size = GetSize();
|
|
//dc.SetPen(wxPen(m_road_def_color, 2, wxPENSTYLE_SOLID));
|
|
dc.SetPen(wxPen(AMS_CONTROL_GRAY500, 2, wxPENSTYLE_SOLID));
|
|
dc.SetBrush(wxBrush(*wxTRANSPARENT_BRUSH));
|
|
|
|
if ((m_ams_model == N3S_AMS || m_ams_model == EXT_AMS) && m_amsinfo.cans.size() != 4){
|
|
dc.DrawLine(((float)size.x / 2), (0), ((float)size.x / 2), (size.y));
|
|
if (m_load_step == AMSPassRoadSTEP::AMS_ROAD_STEP_2 || m_load_step == AMSPassRoadSTEP::AMS_ROAD_STEP_3){
|
|
dc.SetPen(wxPen(_get_diff_clr(this, m_amsinfo.cans[m_load_slot_index].material_colour), 4, wxPENSTYLE_SOLID));
|
|
dc.DrawLine((size.x / 2), (0), (size.x / 2), (size.y));
|
|
}
|
|
}
|
|
else{
|
|
auto x_start = FromDIP(40);
|
|
auto x = x_start;
|
|
auto width = FromDIP(63);
|
|
auto height = FromDIP(21);
|
|
for (int i = 0; i < 4; i++){
|
|
dc.DrawLine((x), (0), (x), (height));
|
|
x += width;
|
|
}
|
|
x -= width;
|
|
dc.DrawLine((x_start), (height), (x), (height));
|
|
dc.DrawLine((size.x / 2), (height), (size.x / 2), (size.y));
|
|
|
|
dc.SetPen(wxPen(_get_diff_clr(this, m_amsinfo.cans[m_load_slot_index].material_colour), 4, wxPENSTYLE_SOLID));
|
|
auto temp = m_amsinfo;
|
|
if (m_load_step != AMSPassRoadSTEP::AMS_ROAD_STEP_NONE){
|
|
if (m_amsinfo.cans.size() <= m_load_slot_index || m_load_slot_index < 0){
|
|
BOOST_LOG_TRIVIAL(trace) << "up road render error";
|
|
return;
|
|
}
|
|
x = x_start + m_load_slot_index * width;
|
|
dc.DrawLine((x), (0), (x), (height));
|
|
if (x < size.x / 2){
|
|
dc.DrawLine((x), (height), (size.x / 2), (height));
|
|
}
|
|
else {
|
|
dc.DrawLine((size.x / 2), (height), (x), (height));
|
|
}
|
|
if(m_load_step == AMSPassRoadSTEP::AMS_ROAD_STEP_2 || m_load_step == AMSPassRoadSTEP::AMS_ROAD_STEP_3){
|
|
dc.DrawLine((size.x / 2), (height), (size.x / 2), (size.y));
|
|
}
|
|
}
|
|
dc.SetPen(wxPen(*wxTRANSPARENT_PEN));
|
|
dc.SetBrush(wxBrush(wxColour(194, 194, 194)));
|
|
//width = 0.11 * size.x, height = 0.294 * size.y;
|
|
//dc.DrawRectangle((size.x - width) / 2, (16), (28), (10));
|
|
//dc.DrawRectangle((size.x - width) / 2, (size.y * 0.62 - height / 2), (width), (height));
|
|
dc.DrawRectangle(size.x / 2 - FromDIP(14), height - FromDIP(5), FromDIP(28), FromDIP(10));
|
|
}
|
|
// left mode
|
|
}
|
|
|
|
void AMSRoadUpPart::UpdatePassRoad(std::string ams_index, std::string slot_index, AMSPassRoadType type, AMSPassRoadSTEP step)
|
|
{
|
|
int ams_idx = atoi(ams_index.c_str());
|
|
int slot_idx = atoi(slot_index.c_str());
|
|
if (m_load_ams_index == ams_idx && m_load_slot_index == slot_idx && m_load_step == step)
|
|
{
|
|
return;
|
|
};
|
|
|
|
m_load_ams_index = ams_idx;
|
|
m_load_slot_index = slot_idx;
|
|
m_load_step = step;
|
|
Refresh();
|
|
}
|
|
|
|
void AMSRoadUpPart::OnPassRoad(std::vector<AMSPassRoadMode> prord_list)
|
|
{
|
|
// AMS_ROAD_MODE_NONE, AMS_ROAD_MODE_LEFT, AMS_ROAD_MODE_LEFT_RIGHT, AMS_ROAD_MODE_END_TOP, AMS_ROAD_MODE_END_BOTTOM, AMS_ROAD_MODE_END_RIGHT,
|
|
// AMS_ROAD_MODE_LEFT, AMS_ROAD_MODE_LEFT_RIGHT, AMS_ROAD_MODE_END,
|
|
//wait fill
|
|
}
|
|
|
|
void AMSRoadUpPart::msw_rescale() {
|
|
Layout();
|
|
Fit();
|
|
Refresh();
|
|
}
|
|
|
|
|
|
|
|
/*************************************************
|
|
Description:AMSRoadDownPart
|
|
**************************************************/
|
|
AMSRoadDownPart::AMSRoadDownPart(){}
|
|
AMSRoadDownPart::AMSRoadDownPart(wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size)
|
|
: AMSRoadDownPart()
|
|
{
|
|
/*m_info = info;
|
|
m_canindex = canindex;*/
|
|
// road type
|
|
m_road_color[0] = AMS_CONTROL_GRAY500;
|
|
m_road_color[1] = AMS_CONTROL_GRAY500;
|
|
m_left_rode_mode = AMSRoadShowMode::AMS_ROAD_MODE_FOUR;
|
|
m_right_rode_mode = AMSRoadShowMode::AMS_ROAD_MODE_FOUR;
|
|
m_selected = false;
|
|
|
|
m_left_road_length = -1;
|
|
m_right_road_length = -1;
|
|
create(parent, id, pos, size);
|
|
this->SetMinSize(AMS_DOWN_ROAD_SIZE);
|
|
this->SetSize(AMS_DOWN_ROAD_SIZE);
|
|
|
|
Bind(wxEVT_PAINT, &AMSRoadDownPart::paintEvent, this);
|
|
wxWindow::SetBackgroundColour(*wxWHITE);
|
|
|
|
}
|
|
|
|
void AMSRoadDownPart::create(wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size) { wxWindow::Create(parent, id, pos, size); }
|
|
|
|
void AMSRoadDownPart::UpdateLeft(int nozzle_num, AMSRoadShowMode mode)
|
|
{
|
|
if (nozzle_num == m_nozzle_num && m_left_rode_mode == mode) { return;}
|
|
|
|
this->m_left_rode_mode = mode;
|
|
m_nozzle_num = nozzle_num;
|
|
Refresh();
|
|
}
|
|
void AMSRoadDownPart::UpdateRight(int nozzle_num, AMSRoadShowMode mode)
|
|
{
|
|
if (nozzle_num == m_nozzle_num && m_right_rode_mode == mode) { return; }
|
|
|
|
this->m_right_rode_mode = mode;
|
|
m_nozzle_num = nozzle_num;
|
|
Refresh();
|
|
}
|
|
|
|
void AMSRoadDownPart::OnVamsLoading(bool load, wxColour col /*= AMS_CONTROL_GRAY500*/)
|
|
{
|
|
/*m_vams_loading = load;
|
|
if(load)m_road_color = col;
|
|
Refresh();*/
|
|
}
|
|
|
|
void AMSRoadDownPart::SetPassRoadColour(bool left, wxColour col)
|
|
{
|
|
if (left)
|
|
{
|
|
if (m_road_color[DEPUTY_NOZZLE_ID] == col)
|
|
{
|
|
return;
|
|
}
|
|
m_road_color[DEPUTY_NOZZLE_ID] = col;
|
|
}
|
|
else
|
|
{
|
|
if (m_road_color[MAIN_NOZZLE_ID] == col)
|
|
{
|
|
return;
|
|
}
|
|
m_road_color[MAIN_NOZZLE_ID] = col;
|
|
}
|
|
|
|
Refresh();
|
|
}
|
|
|
|
void AMSRoadDownPart::SetShowMode(AMSRoadShowMode left_mode, AMSRoadShowMode right_mode)
|
|
{
|
|
if (m_left_rode_mode == left_mode && m_right_rode_mode == right_mode) { return; }
|
|
|
|
m_left_rode_mode = left_mode;
|
|
m_right_rode_mode = right_mode;
|
|
Refresh();
|
|
}
|
|
|
|
void AMSRoadDownPart::paintEvent(wxPaintEvent& evt)
|
|
{
|
|
wxPaintDC dc(this);
|
|
render(dc);
|
|
}
|
|
|
|
void AMSRoadDownPart::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 AMSRoadDownPart::doRender(wxDC& dc)
|
|
{
|
|
wxSize size = GetSize();
|
|
wxPoint left_nozzle_pos = wxPoint(std::ceil((float)size.x / 2 - FromDIP(8)), FromDIP(258));
|
|
wxPoint right_nozzle_pos = wxPoint(std::ceil((float)size.x / 2 + FromDIP(6)), FromDIP(258));
|
|
/*if (m_road_color.Alpha() == 0) { dc.SetPen(wxPen(*wxWHITE, m_passroad_width, wxPENSTYLE_SOLID)); }
|
|
else { dc.SetPen(wxPen(m_road_color, m_passroad_width, wxPENSTYLE_SOLID)); }*/
|
|
dc.SetPen(wxPen(AMS_CONTROL_GRAY500, 2, wxPENSTYLE_SOLID));
|
|
auto xpos = left_nozzle_pos.x;
|
|
if (m_left_rode_mode == AMSRoadShowMode::AMS_ROAD_MODE_NONE || m_right_rode_mode == AMSRoadShowMode::AMS_ROAD_MODE_NONE){
|
|
auto length = 50;
|
|
if (m_left_rode_mode == AMSRoadShowMode::AMS_ROAD_MODE_AMS_LITE || m_right_rode_mode == AMSRoadShowMode::AMS_ROAD_MODE_AMS_LITE)
|
|
length = -13;
|
|
dc.DrawLine(left_nozzle_pos.x - FromDIP(length), (size.y / 2), (left_nozzle_pos.x), (size.y / 2));
|
|
dc.DrawLine(left_nozzle_pos.x - FromDIP(length), (0), left_nozzle_pos.x - FromDIP(length), (size.y / 2));
|
|
dc.DrawLine(left_nozzle_pos.x, size.y / 2, left_nozzle_pos.x, size.y);
|
|
}
|
|
else {
|
|
switch (m_left_rode_mode)
|
|
{
|
|
case AMSRoadShowMode::AMS_ROAD_MODE_FOUR:
|
|
dc.DrawLine(left_nozzle_pos.x - FromDIP((129)), (size.y / 2), left_nozzle_pos.x, (size.y / 2));
|
|
dc.DrawLine(left_nozzle_pos.x - FromDIP((129)), 0, left_nozzle_pos.x - FromDIP((129)), (size.y / 2));
|
|
break;
|
|
case AMSRoadShowMode::AMS_ROAD_MODE_DOUBLE:
|
|
dc.DrawLine(left_nozzle_pos.x - FromDIP(218), (size.y / 2), left_nozzle_pos.x, (size.y / 2));
|
|
dc.DrawLine(left_nozzle_pos.x - FromDIP(110), 0, left_nozzle_pos.x - FromDIP(110), (size.y / 2));
|
|
dc.DrawLine(left_nozzle_pos.x - FromDIP(218), 0, left_nozzle_pos.x - FromDIP(218), (size.y / 2));
|
|
break;
|
|
case AMSRoadShowMode::AMS_ROAD_MODE_SINGLE:
|
|
dc.DrawLine(left_nozzle_pos.x - FromDIP(192), (size.y / 2), left_nozzle_pos.x, (size.y / 2));
|
|
dc.DrawLine(left_nozzle_pos.x - FromDIP(192), 0, left_nozzle_pos.x - FromDIP(192), (size.y / 2));
|
|
break;
|
|
case AMSRoadShowMode::AMS_ROAD_MODE_AMS_LITE:
|
|
dc.DrawLine(left_nozzle_pos.x, 0, left_nozzle_pos.x, size.y);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
switch (m_right_rode_mode)
|
|
{
|
|
case AMSRoadShowMode::AMS_ROAD_MODE_FOUR:
|
|
dc.DrawLine(right_nozzle_pos.x, (size.y / 2), right_nozzle_pos.x + FromDIP(131), (size.y / 2));
|
|
dc.DrawLine(right_nozzle_pos.x + FromDIP(131), 0, right_nozzle_pos.x + FromDIP(131), (size.y / 2));
|
|
break;
|
|
case AMSRoadShowMode::AMS_ROAD_MODE_DOUBLE:
|
|
dc.DrawLine(right_nozzle_pos.x, (size.y / 2), right_nozzle_pos.x + FromDIP(218), (size.y / 2));
|
|
dc.DrawLine(right_nozzle_pos.x + FromDIP(110), 0, right_nozzle_pos.x + FromDIP(110), (size.y / 2));
|
|
dc.DrawLine(right_nozzle_pos.x + FromDIP(218), 0, right_nozzle_pos.x + FromDIP(218), (size.y / 2));
|
|
break;
|
|
case AMSRoadShowMode::AMS_ROAD_MODE_SINGLE:
|
|
dc.DrawLine(right_nozzle_pos.x, (size.y / 2), right_nozzle_pos.x + FromDIP(68), (size.y / 2));
|
|
dc.DrawLine(right_nozzle_pos.x + FromDIP(68), 0, right_nozzle_pos.x + FromDIP(68), (size.y / 2));
|
|
break;
|
|
case AMSRoadShowMode::AMS_ROAD_MODE_AMS_LITE:
|
|
dc.DrawLine(left_nozzle_pos.x, (size.y / 2), left_nozzle_pos.x + FromDIP(145), (size.y / 2));
|
|
dc.DrawLine(left_nozzle_pos.x + FromDIP(145), 0, left_nozzle_pos.x + FromDIP(145), (size.y / 2));
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (m_right_rode_mode != AMSRoadShowMode::AMS_ROAD_MODE_AMS_LITE){
|
|
if (m_nozzle_num == 2) {
|
|
/*dc.DrawLine(FromDIP(left_nozzle_pos.x), FromDIP(size.y / 2), FromDIP(left_nozzle_pos.x), FromDIP(size.y));
|
|
dc.DrawLine(FromDIP(right_nozzle_pos.x), FromDIP(size.y / 2), FromDIP(right_nozzle_pos.x), FromDIP(size.y));*/
|
|
dc.DrawLine((left_nozzle_pos.x), (size.y / 2), (left_nozzle_pos.x), (size.y));
|
|
dc.DrawLine((right_nozzle_pos.x), (size.y / 2), (right_nozzle_pos.x), (size.y));
|
|
}
|
|
else {
|
|
if (m_right_rode_mode != AMSRoadShowMode::AMS_ROAD_MODE_NONE && m_left_rode_mode != AMSRoadShowMode::AMS_ROAD_MODE_NONE) {
|
|
dc.DrawLine((left_nozzle_pos.x), (size.y / 2), (right_nozzle_pos.x), (size.y / 2));
|
|
}
|
|
dc.DrawLine((left_nozzle_pos.x), (size.y / 2), (left_nozzle_pos.x), (size.y));
|
|
}
|
|
}
|
|
|
|
|
|
/*if (m_nozzle_mode == AMSRoadDownPartMode::AMS_ROAD_MODE_SINGLE)
|
|
{
|
|
dc.DrawLine(left_nozzle_pos.x, left_nozzle_pos.y, FromDIP(left_nozzle_pos.x + 30), left_nozzle_pos.y);
|
|
}*/
|
|
//dc.SetBrush(wxBrush(*wxBLUE));
|
|
|
|
if (m_pass_road_right_step == AMSPassRoadSTEP::AMS_ROAD_STEP_2 || m_pass_road_right_step == AMSPassRoadSTEP::AMS_ROAD_STEP_3) {
|
|
dc.SetPen(wxPen(_get_diff_clr(this, m_road_color[0]), 4, wxPENSTYLE_SOLID));
|
|
if (m_right_road_length > 0) {
|
|
if (m_right_rode_mode == AMSRoadShowMode::AMS_ROAD_MODE_AMS_LITE){
|
|
/* dc.SetPen(wxPen(*wxRED));
|
|
dc.DrawLine(right_nozzle_pos.x, 0, right_nozzle_pos.x + , size.y / 2);
|
|
xpos = left_nozzle_pos.x;
|
|
if (m_nozzle_num >= 2) xpos = right_nozzle_pos.x;
|
|
dc.SetPen(wxPen(*wxGREEN));
|
|
dc.DrawLine(xpos, size.y / 2, right_nozzle_pos.x, size.y / 2);
|
|
dc.SetPen(wxPen(*wxYELLOW));
|
|
dc.DrawLine(xpos, size.y / 2, xpos, size.y);*/
|
|
int x = left_nozzle_pos.x;
|
|
int len = m_right_road_length;
|
|
if (m_nozzle_num == 2) {
|
|
x = right_nozzle_pos.x;
|
|
len = len - 14;
|
|
}
|
|
dc.DrawLine(((x)), (size.y / 2), x + FromDIP(len), (size.y / 2));
|
|
dc.DrawLine(x + FromDIP(len), (0), x + FromDIP(len), (size.y / 2));
|
|
dc.DrawLine((x), (size.y / 2), (x), (size.y));
|
|
}
|
|
else{
|
|
int x = left_nozzle_pos.x;
|
|
int len = m_right_road_length;
|
|
if (m_nozzle_num == 2) {
|
|
x = right_nozzle_pos.x;
|
|
len = len - 14;
|
|
}
|
|
dc.DrawLine(((x)), (size.y / 2), x + FromDIP(len), (size.y / 2));
|
|
dc.DrawLine(x + FromDIP(len), (0), x + FromDIP(len), (size.y / 2));
|
|
dc.DrawLine((x), (size.y / 2), (x), (size.y));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (m_pass_road_left_step == AMSPassRoadSTEP::AMS_ROAD_STEP_2 || m_pass_road_left_step == AMSPassRoadSTEP::AMS_ROAD_STEP_3) {
|
|
dc.SetPen(wxPen(_get_diff_clr(this, m_road_color[1]), 4, wxPENSTYLE_SOLID));
|
|
if (m_left_road_length > 0) {
|
|
if (m_left_rode_mode == AMSRoadShowMode::AMS_ROAD_MODE_AMS_LITE){
|
|
dc.DrawLine(left_nozzle_pos.x, 0, left_nozzle_pos.x, size.y);
|
|
}
|
|
else{
|
|
dc.DrawLine((left_nozzle_pos.x - FromDIP(m_left_road_length)), (size.y / 2), (left_nozzle_pos.x), (size.y / 2));
|
|
dc.DrawLine((left_nozzle_pos.x), (size.y / 2), (left_nozzle_pos.x), (size.y));
|
|
dc.DrawLine(left_nozzle_pos.x - FromDIP(m_left_road_length), (0), left_nozzle_pos.x - FromDIP(m_left_road_length), (size.y / 2));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void AMSRoadDownPart::UpdatePassRoad(AMSPanelPos pos, int len, AMSPassRoadSTEP step) {
|
|
if (m_nozzle_num >= 2){
|
|
if (pos == AMSPanelPos::LEFT_PANEL){
|
|
if (m_left_road_length == len && m_pass_road_left_step == step){ return; }
|
|
m_left_road_length = len;;
|
|
m_pass_road_left_step = step;
|
|
}
|
|
else{
|
|
if (m_right_road_length == len && m_pass_road_right_step == step) { return; }
|
|
m_right_road_length = len;
|
|
m_pass_road_right_step = step;
|
|
}
|
|
}
|
|
else{
|
|
if (pos == AMSPanelPos::LEFT_PANEL) {
|
|
if (m_left_road_length == len && m_pass_road_left_step == step && m_right_road_length == -1) { return; }
|
|
m_left_road_length = len;
|
|
m_right_road_length = -1;
|
|
m_pass_road_left_step = step;
|
|
}
|
|
else {
|
|
if (m_right_road_length == len && m_pass_road_right_step == step && m_left_road_length == -1) { return; }
|
|
m_right_road_length = len;
|
|
m_left_road_length = -1;
|
|
m_pass_road_right_step = step;
|
|
}
|
|
}
|
|
Refresh();
|
|
}
|
|
|
|
void AMSRoadDownPart::msw_rescale() {
|
|
Layout();
|
|
Fit();
|
|
Refresh();
|
|
}
|
|
|
|
/*************************************************
|
|
Description:AMSPreview
|
|
**************************************************/
|
|
AMSPreview::AMSPreview() {}
|
|
|
|
AMSPreview::AMSPreview(wxWindow* parent, wxWindowID id, AMSinfo amsinfo, AMSModel itemType, const wxPoint& pos, const wxSize& size) : AMSPreview()
|
|
{
|
|
wxWindow::Create(parent, id, pos);
|
|
if (itemType == AMSModel::GENERIC_AMS || itemType == AMSModel::AMS_LITE || itemType == AMSModel::N3F_AMS) {
|
|
create(parent, id, pos, AMS_PREV_FOUR_SIZE);
|
|
}
|
|
else {
|
|
create(parent, id, pos, AMS_PREV_SINGLE_SIZE);
|
|
}
|
|
m_amsinfo = amsinfo;
|
|
m_ams_item_type = itemType;
|
|
//create(parent, id, pos, AMS_PREVIEW_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)
|
|
{
|
|
if (m_amsinfo == amsinfo)
|
|
{
|
|
return;
|
|
}
|
|
|
|
m_amsinfo = amsinfo;
|
|
m_ams_item_type = amsinfo.ams_type;
|
|
|
|
if (m_ams_item_type == AMSModel::GENERIC_AMS || m_ams_item_type == AMSModel::AMS_LITE || m_ams_item_type == AMSModel::N3F_AMS) {
|
|
SetMinSize(AMS_PREV_FOUR_SIZE);
|
|
SetMaxSize(AMS_PREV_FOUR_SIZE);
|
|
} else {
|
|
SetMinSize(AMS_PREV_SINGLE_SIZE);
|
|
SetMaxSize(AMS_PREV_SINGLE_SIZE);
|
|
}
|
|
|
|
Refresh();
|
|
}
|
|
|
|
void AMSPreview::create(wxWindow *parent, wxWindowID id, const wxPoint &pos, const wxSize &size)
|
|
{
|
|
m_ts_bitmap_cube = ScalableBitmap(this, "ts_bitmap_cube", 12);
|
|
m_ts_bitmap_cube_dark = ScalableBitmap(this, "ts_bitmap_cube_dark", 12);
|
|
|
|
m_four_slot_bitmap = ScalableBitmap(this, "four_slot_ams_item", 32);
|
|
m_four_slot_bitmap_dark = ScalableBitmap(this, "four_slot_ams_item_dark", 32);
|
|
|
|
m_single_slot_bitmap = ScalableBitmap(this, "single_slot_ams_item", 32);
|
|
m_single_slot_bitmap_dark = ScalableBitmap(this, "single_slot_ams_item_dark", 32);
|
|
|
|
SetMinSize(size);
|
|
SetMaxSize(size);
|
|
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(*wxTRANSPARENT_PEN));
|
|
|
|
// draw background
|
|
if (wxGetApp().dark_mode())
|
|
{
|
|
dc.SetBrush(StateColor::darkModeColorFor(*wxWHITE));
|
|
}
|
|
else
|
|
{
|
|
dc.SetBrush(AMS_CONTROL_DEF_BLOCK_BK_COLOUR);
|
|
}
|
|
dc.DrawRoundedRectangle(0, 0, size.x, size.y, 0);
|
|
|
|
// draw container
|
|
auto color = *wxWHITE;
|
|
dc.SetBrush(StateColor::darkModeColorFor(color));
|
|
dc.DrawRoundedRectangle(0, 0, size.x, size.y, FromDIP(3));
|
|
|
|
auto left = 0;
|
|
//four slot
|
|
if (m_ams_item_type != AMSModel::EXT_AMS && m_ams_item_type != AMSModel::N3S_AMS){
|
|
left = FromDIP(8);
|
|
for (std::vector<Caninfo>::iterator iter = m_amsinfo.cans.begin(); iter != m_amsinfo.cans.end(); iter++) {
|
|
|
|
dc.SetPen(wxPen(*wxTRANSPARENT_PEN));
|
|
|
|
if (wxWindow::IsThisEnabled()) {
|
|
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;
|
|
|
|
int gwidth = (AMS_ITEM_CUBE_SIZE.x / (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]));
|
|
int x = left + AMS_ITEM_CUBE_SIZE.x * i / cols_size;
|
|
dc.DrawRectangle(x, (size.y - AMS_ITEM_CUBE_SIZE.y) / 2, AMS_ITEM_CUBE_SIZE.x / cols_size, AMS_ITEM_CUBE_SIZE.y);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
if (iter->material_colour.Alpha() == 0) {
|
|
if (wxGetApp().dark_mode())
|
|
{
|
|
dc.DrawBitmap(m_ts_bitmap_cube_dark.bmp(), left - FromDIP(2), (size.y - m_ts_bitmap_cube_dark.GetBmpHeight()) / 2);
|
|
}
|
|
else
|
|
{
|
|
dc.DrawBitmap(m_ts_bitmap_cube.bmp(), left - FromDIP(2), (size.y - m_ts_bitmap_cube.GetBmpHeight()) / 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.DrawLine(rect.GetRight() - FromDIP(1), rect.GetTop() + FromDIP(1), rect.GetLeft() + FromDIP(1), rect.GetBottom() - FromDIP(1));
|
|
}
|
|
else {
|
|
dc.DrawRoundedRectangle(rect, 2);
|
|
}
|
|
}
|
|
}
|
|
left += AMS_ITEM_CUBE_SIZE.x;
|
|
}
|
|
|
|
//auto pot = wxPoint((size.x - m_four_slot_bitmap.GetBmpSize().x) / 2, (size.y - m_four_slot_bitmap.GetBmpSize().y) / 2);
|
|
if (wxGetApp().dark_mode())
|
|
{
|
|
dc.DrawBitmap(m_four_slot_bitmap_dark.bmp(), wxPoint(0, 0));
|
|
}
|
|
else
|
|
{
|
|
dc.DrawBitmap(m_four_slot_bitmap.bmp(), wxPoint(0, 0));
|
|
}
|
|
|
|
}
|
|
|
|
//single slot
|
|
else if (m_amsinfo.cans.size() == 1) {
|
|
auto iter = m_amsinfo.cans[0];
|
|
dc.SetPen(wxPen(*wxTRANSPARENT_PEN));
|
|
dc.SetBrush(StateColor::darkModeColorFor(AMS_CONTROL_DEF_BLOCK_BK_COLOUR));
|
|
wxSize rec_size = wxSize(FromDIP(16), FromDIP(24));
|
|
dc.DrawRoundedRectangle((size.x - rec_size.x) / 2, (size.y - rec_size.y) / 2, rec_size.x, rec_size.y, FromDIP(2));
|
|
if (iter.material_cols.size() > 1)
|
|
{
|
|
int fleft = (size.x - AMS_ITEM_CUBE_SIZE.x) / 2;
|
|
|
|
float total_width = AMS_ITEM_CUBE_SIZE.x;
|
|
int gwidth = (total_width / (iter.material_cols.size()));
|
|
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.SetPen(wxPen(*wxTRANSPARENT_PEN));
|
|
dc.SetBrush(wxBrush(iter.material_cols[i]));
|
|
float x = (size.x - AMS_ITEM_CUBE_SIZE.x) / 2 + total_width * i / cols_size;
|
|
dc.DrawRectangle(x, (size.y - AMS_ITEM_CUBE_SIZE.y) / 2, total_width / cols_size, AMS_ITEM_CUBE_SIZE.y);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
dc.SetPen(wxPen(*wxTRANSPARENT_PEN));
|
|
dc.SetBrush(iter.material_colour);
|
|
//dc.SetBrush(*wxGREEN);
|
|
if (m_ams_item_type == AMSModel::N3S_AMS) {
|
|
auto rect = wxRect(((size.x - AMS_ITEM_CUBE_SIZE.x) / 2), ((size.y - AMS_ITEM_CUBE_SIZE.y) / 2), (AMS_ITEM_CUBE_SIZE.x), (AMS_ITEM_CUBE_SIZE.y));
|
|
dc.DrawRoundedRectangle(rect, 0);
|
|
} else {
|
|
auto rect = wxRect(((size.x - AMS_ITEM_CUBE_SIZE2.x) / 2), ((size.y - AMS_ITEM_CUBE_SIZE2.y) / 2), (AMS_ITEM_CUBE_SIZE2.x), (AMS_ITEM_CUBE_SIZE2.y));
|
|
dc.DrawRoundedRectangle(rect, FromDIP(3));
|
|
}
|
|
}
|
|
|
|
if (m_ams_item_type == AMSModel::N3S_AMS) {
|
|
//auto pot = wxPoint(((size.x - m_single_slot_bitmap.GetBmpSize().x) / 2), ((size.y - m_single_slot_bitmap.GetBmpSize().y) / 2));
|
|
if (wxGetApp().dark_mode())
|
|
{
|
|
dc.DrawBitmap(m_single_slot_bitmap_dark.bmp(), wxPoint(0, 0));
|
|
}
|
|
else
|
|
{
|
|
dc.DrawBitmap(m_single_slot_bitmap.bmp(), wxPoint(0, 0));
|
|
}
|
|
|
|
}
|
|
if (((iter.material_colour.Red() >= 238 && iter.material_colour.Green() >= 238 && iter.material_colour.Blue() >= 238)
|
|
|| iter.material_colour.Alpha() == 0) && m_ams_item_type == AMSModel::EXT_AMS) {
|
|
dc.SetPen(wxPen(AMS_CONTROL_GRAY500));
|
|
dc.SetBrush(wxBrush(*wxTRANSPARENT_BRUSH));
|
|
auto rect = wxRect(((size.x - AMS_ITEM_CUBE_SIZE2.x) / 2), ((size.y - AMS_ITEM_CUBE_SIZE2.y) / 2), (AMS_ITEM_CUBE_SIZE2.x), (AMS_ITEM_CUBE_SIZE2.y));
|
|
dc.DrawRoundedRectangle(rect, FromDIP(3));
|
|
}
|
|
}
|
|
auto border_colour = AMS_CONTROL_BRAND_COLOUR;
|
|
if (!wxWindow::IsEnabled()) { border_colour = AMS_CONTROL_DISABLE_COLOUR; }
|
|
|
|
if (m_hover) {
|
|
dc.SetPen(wxPen(border_colour, 1));
|
|
dc.SetBrush(wxBrush(*wxTRANSPARENT_BRUSH));
|
|
dc.DrawRoundedRectangle(0, 0, size.x, size.y, 3);
|
|
|
|
}
|
|
|
|
if (m_selected) {
|
|
dc.SetPen(wxPen(border_colour, 1));
|
|
dc.SetBrush(wxBrush(*wxTRANSPARENT_BRUSH));
|
|
dc.DrawRoundedRectangle(0, 0, size.x, size.y, 3);
|
|
}
|
|
}
|
|
|
|
void AMSPreview::msw_rescale()
|
|
{
|
|
m_ts_bitmap_cube.msw_rescale();
|
|
m_ts_bitmap_cube_dark.msw_rescale();
|
|
m_four_slot_bitmap.msw_rescale();
|
|
m_four_slot_bitmap_dark.msw_rescale();
|
|
m_single_slot_bitmap.msw_rescale();
|
|
m_single_slot_bitmap_dark.msw_rescale();
|
|
|
|
Refresh();
|
|
}
|
|
|
|
|
|
/*************************************************
|
|
Description:AMSHumidity
|
|
**************************************************/
|
|
|
|
AMSHumidity::AMSHumidity() {}
|
|
AMSHumidity::AMSHumidity(wxWindow* parent, wxWindowID id, AMSinfo info, const wxPoint& pos, const wxSize& size)
|
|
: AMSHumidity()
|
|
{
|
|
m_amsinfo = info;
|
|
// road type
|
|
|
|
for (int i = 1; i <= 5; i++) {
|
|
ams_humidity_img.push_back(ScalableBitmap(this, "hum_level" + std::to_string(i) + "_light", 16));
|
|
}
|
|
|
|
for (int i = 1; i <= 5; i++) {
|
|
ams_humidity_img.push_back(ScalableBitmap(this, "hum_level" + std::to_string(i) + "_dark", 16));
|
|
}
|
|
ams_sun_img = ScalableBitmap(this, "ams_drying", 16);
|
|
create(parent, id, pos, AMS_HUMIDITY_SIZE);
|
|
|
|
Bind(wxEVT_PAINT, &AMSHumidity::paintEvent, this);
|
|
//wxWindow::SetBackgroundColour(AMS_CONTROL_DEF_HUMIDITY_BK_COLOUR);
|
|
|
|
Bind(wxEVT_LEFT_UP, [this](wxMouseEvent& e) {
|
|
if (m_show_humidity) {
|
|
auto mouse_pos = ClientToScreen(e.GetPosition());
|
|
auto rect = ClientToScreen(wxPoint(0, 0));
|
|
|
|
if (mouse_pos.x > rect.x &&
|
|
mouse_pos.y > rect.y) {
|
|
wxCommandEvent show_event(EVT_AMS_SHOW_HUMIDITY_TIPS);
|
|
show_event.SetInt(m_amsinfo.ams_humidity);
|
|
wxPostEvent(GetParent()->GetParent(), show_event);
|
|
|
|
#ifdef __WXMSW__
|
|
wxCommandEvent close_event(EVT_CLEAR_SPEED_CONTROL);
|
|
wxPostEvent(GetParent()->GetParent(), close_event);
|
|
#endif // __WXMSW__
|
|
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
void AMSHumidity::create(wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size) {
|
|
wxWindow::Create(parent, id, pos, size);
|
|
SetSize(size);
|
|
SetMinSize(size);
|
|
SetBackgroundColour(StateColor::darkModeColorFor(AMS_CONTROL_DEF_LIB_BK_COLOUR));
|
|
Refresh();
|
|
}
|
|
|
|
|
|
void AMSHumidity::Update(AMSinfo amsinfo)
|
|
{
|
|
m_amsinfo = amsinfo;
|
|
Refresh();
|
|
}
|
|
|
|
|
|
void AMSHumidity::paintEvent(wxPaintEvent& evt)
|
|
{
|
|
wxPaintDC dc(this);
|
|
render(dc);
|
|
}
|
|
|
|
void AMSHumidity::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 AMSHumidity::doRender(wxDC& dc)
|
|
{
|
|
wxSize size = GetSize();
|
|
|
|
dc.SetPen(wxPen(*wxTRANSPARENT_PEN));
|
|
dc.SetBrush(wxBrush(StateColor::darkModeColorFor(AMS_CONTROL_DEF_BLOCK_BK_COLOUR)));
|
|
// left mode
|
|
if (m_amsinfo.ams_humidity >= 1 && m_amsinfo.ams_humidity <= 5) { m_show_humidity = true; }
|
|
else { m_show_humidity = false; }
|
|
if (m_amsinfo.ams_humidity >= 1 && m_amsinfo.ams_humidity <= 5) {
|
|
//background
|
|
dc.SetPen(wxPen(*wxTRANSPARENT_PEN));
|
|
dc.SetBrush(wxBrush(StateColor::darkModeColorFor(AMS_CONTROL_DEF_BLOCK_BK_COLOUR)));
|
|
dc.DrawRoundedRectangle(0, 0, (size.x), (size.y), (size.y / 2));
|
|
|
|
//hum image
|
|
int hum_idx = m_amsinfo.ams_humidity - 1;
|
|
if (wxGetApp().dark_mode()) {
|
|
hum_idx += 5;
|
|
}
|
|
if (hum_idx >= ams_humidity_img.size() || hum_idx < 0){
|
|
BOOST_LOG_TRIVIAL(trace) << "humidity error";
|
|
}
|
|
auto hum_img = ams_humidity_img[hum_idx];
|
|
auto pot = wxPoint(FromDIP(5), ((size.y - hum_img.GetBmpSize().y) / 2));
|
|
dc.DrawBitmap(hum_img.bmp(), pot);
|
|
|
|
//percentage
|
|
wxString hum_percentage = _L(std::to_string(20 * (5 - m_amsinfo.ams_humidity + 1)));
|
|
auto tsize = dc.GetMultiLineTextExtent(hum_percentage);
|
|
dc.SetPen(wxPen(*wxTRANSPARENT_PEN));
|
|
dc.SetFont(Label::Body_14);
|
|
dc.SetTextForeground(StateColor::darkModeColorFor(AMS_CONTROL_BLACK_COLOUR));
|
|
//pot = wxPoint(FromDIP(size.x * 0.3), FromDIP((size.y - tsize.y) / 2));
|
|
pot.x = pot.x + hum_img.GetBmpSize().x + FromDIP(3);
|
|
dc.DrawText(hum_percentage, pot);
|
|
|
|
pot.x += (tsize.x + FromDIP(5));
|
|
dc.SetFont(Label::Body_12);
|
|
tsize = dc.GetMultiLineTextExtent(_L("%"));
|
|
pot.y += (tsize.y / 2 - FromDIP(4));
|
|
dc.DrawText(_L("%"), pot);
|
|
|
|
//vertical line
|
|
pot.x = pot.x + tsize.x + FromDIP(2);
|
|
dc.SetPen(wxPen(wxColour(194, 194, 194)));
|
|
dc.SetBrush(wxBrush(wxColour(194, 194, 194)));
|
|
//dc.DrawLine(FromDIP(GetSize().x * 0.64), FromDIP(GetSize().y / 2 - 10), FromDIP(GetSize().x * 0.64), FromDIP(GetSize().y / 2 + 10));
|
|
dc.DrawLine(pot.x, GetSize().y / 2 - FromDIP(10), pot.x, GetSize().y / 2 + FromDIP(10));
|
|
|
|
//sun image
|
|
/*pot.x = FromDIP(size.x * 0.69);
|
|
pot.y = FromDIP((size.y - ams_sun_img.GetBmpHeight()) / 2);*/
|
|
pot.x = pot.x + FromDIP(ams_sun_img.GetBmpWidth() / 2);
|
|
pot.y = FromDIP((size.y - ams_sun_img.GetBmpHeight()) / 2);
|
|
dc.SetPen(wxPen(*wxTRANSPARENT_PEN));
|
|
dc.DrawBitmap(ams_sun_img.bmp(), pot);
|
|
|
|
}
|
|
else {
|
|
//to do ...
|
|
}
|
|
}
|
|
|
|
void AMSHumidity::msw_rescale() {
|
|
for (int i = 0; i < ams_humidity_img.size(); i++) {
|
|
if (i < ams_humidity_img.size() / 2){
|
|
ams_humidity_img[i] = ScalableBitmap(this, "hum_level" + std::to_string(i + 1) + "_light", 16);
|
|
}
|
|
else{
|
|
ams_humidity_img[i] = ScalableBitmap(this, "hum_level" + std::to_string((i - ams_humidity_img.size() / 2 + 1)) + "_dark", 16);
|
|
}
|
|
}
|
|
ams_sun_img = ScalableBitmap(this, "ams_drying", 16);
|
|
|
|
Layout();
|
|
Refresh();
|
|
}
|
|
|
|
|
|
/*************************************************
|
|
Description:AmsItem
|
|
**************************************************/
|
|
|
|
AmsItem::AmsItem() {}
|
|
|
|
AmsItem::AmsItem(wxWindow *parent,AMSinfo info, AMSModel model, AMSPanelPos pos) : AmsItem()
|
|
{
|
|
m_bitmap_extra_framework = ScalableBitmap(this, "ams_extra_framework_mid_new", 134);
|
|
|
|
SetDoubleBuffered(true);
|
|
m_ams_model = model;
|
|
m_info = info;
|
|
m_panel_pos = pos;
|
|
|
|
if (m_ams_model == AMSModel::GENERIC_AMS){
|
|
wxWindow::Create(parent, wxID_ANY, wxDefaultPosition, AMS_CANS_WINDOW_SIZE);
|
|
SetSize(AMS_CANS_WINDOW_SIZE);
|
|
SetMinSize(AMS_CANS_WINDOW_SIZE);
|
|
SetMaxSize(AMS_CANS_WINDOW_SIZE);
|
|
}
|
|
else{
|
|
wxWindow::Create(parent, wxID_ANY, wxDefaultPosition, AMS_SINGLE_CAN_SIZE);
|
|
SetSize(AMS_SINGLE_CAN_SIZE);
|
|
SetMinSize(AMS_SINGLE_CAN_SIZE);
|
|
SetMaxSize(AMS_SINGLE_CAN_SIZE);
|
|
}
|
|
|
|
create(parent);
|
|
|
|
SetBackgroundColour(StateColor::darkModeColorFor(AMS_CONTROL_DEF_LIB_BK_COLOUR));
|
|
Bind(wxEVT_PAINT, &AmsItem::paintEvent, this);
|
|
}
|
|
|
|
AmsItem::~AmsItem()
|
|
{
|
|
}
|
|
|
|
void AmsItem::create(wxWindow *parent)
|
|
{
|
|
Freeze();
|
|
//if (m_ams_model == AMSModel::GENERIC_AMS)
|
|
if (m_ams_model != AMSModel::AMS_LITE) {
|
|
sizer_can = new wxBoxSizer(wxHORIZONTAL);
|
|
sizer_item = new wxBoxSizer(wxVERTICAL);
|
|
auto it = m_info.cans.begin();
|
|
for (; it != m_info.cans.end(); it++) {
|
|
AddCan(*it, m_can_count, m_info.cans.size(), sizer_can);
|
|
m_can_count++;
|
|
}
|
|
it = m_info.cans.begin();
|
|
//auto road_panel = new wxWindow(this, wxID_ANY);
|
|
//auto road_panel = new wxPanel(this, wxID_ANY);
|
|
//road_panel->SetSize(AMS_CAN_ROAD_SIZE);
|
|
//road_panel->SetMinSize(AMS_CAN_ROAD_SIZE);
|
|
if (m_ams_model == AMSModel::GENERIC_AMS || m_ams_model == AMSModel::N3F_AMS || m_ams_model == AMSModel::N3S_AMS){
|
|
m_humidity = new AMSHumidity(this, wxID_ANY, m_info);
|
|
sizer_item->Add(m_humidity, 0, wxALIGN_CENTER_HORIZONTAL, 0);
|
|
}
|
|
else{
|
|
if (m_ams_model == EXT_AMS){
|
|
m_ext_image = new AMSExtImage(this, m_panel_pos);
|
|
sizer_item->Add(m_ext_image, 0, wxALIGN_CENTER_HORIZONTAL, 0);
|
|
}
|
|
}
|
|
m_panel_road = new AMSRoadUpPart(this, wxID_ANY, m_info, m_ams_model);
|
|
|
|
sizer_item->Add(sizer_can, 0, wxALIGN_CENTER_HORIZONTAL, 0);
|
|
//sizer_item->Add(m_panel_road, 0, wxALIGN_CENTER_HORIZONTAL, 0);
|
|
sizer_item->Add(m_panel_road, 1, wxEXPAND);
|
|
|
|
SetSizer(sizer_item);
|
|
}
|
|
else{
|
|
sizer_can_extra = new wxGridSizer(2, 2, FromDIP(18), FromDIP(20));
|
|
//sizer_can_extra = new wxGridSizer(2, 2, 20, 20);
|
|
sizer_item = new wxBoxSizer(wxVERTICAL);
|
|
if (m_info.cans.size() == GENERIC_AMS_SLOT_NUM){
|
|
AddLiteCan(m_info.cans[0], 0, sizer_can_extra);
|
|
AddLiteCan(m_info.cans[3], 3, sizer_can_extra);
|
|
AddLiteCan(m_info.cans[1], 1, sizer_can_extra);
|
|
AddLiteCan(m_info.cans[2], 2, sizer_can_extra);
|
|
m_can_count = GENERIC_AMS_SLOT_NUM;
|
|
}
|
|
|
|
sizer_item->Add(sizer_can_extra, 0, wxALIGN_CENTER_HORIZONTAL | wxALIGN_TOP, 0);
|
|
//sizer_item->Add(sizer_can_extra, 0, wxALIGN_CENTER);
|
|
SetSizer(sizer_item);
|
|
}
|
|
|
|
|
|
Layout();
|
|
Fit();
|
|
Thaw();
|
|
//Refresh();
|
|
}
|
|
|
|
void AmsItem::AddCan(Caninfo caninfo, int canindex, int maxcan, wxBoxSizer* sizer)
|
|
{
|
|
auto amscan = new wxWindow(this, wxID_ANY);
|
|
|
|
amscan->SetSize(wxSize(FromDIP(52), FromDIP(109)));
|
|
amscan->SetMinSize(wxSize(FromDIP(52), FromDIP(109)));
|
|
|
|
amscan->SetBackgroundColour(StateColor::darkModeColorFor(AMS_CONTROL_DEF_LIB_BK_COLOUR));
|
|
//amscan->SetBackgroundColour(wxTRANSPARENT);
|
|
|
|
wxBoxSizer* m_sizer_ams = new wxBoxSizer(wxVERTICAL);
|
|
|
|
AMSrefresh* m_panel_refresh;
|
|
if (m_ams_model != AMSModel::EXT_AMS)
|
|
{
|
|
m_panel_refresh = new AMSrefresh(amscan, m_info.ams_id, m_can_count, caninfo);
|
|
m_can_refresh_list[caninfo.can_id] = m_panel_refresh;
|
|
}
|
|
else if (m_ams_model == AMSModel::EXT_AMS){
|
|
m_ext_text = new AMSExtText(amscan, wxID_ANY);
|
|
}
|
|
|
|
AMSLib* m_panel_lib = nullptr;
|
|
if (m_ams_model == AMSModel::EXT_AMS && m_info.ext_type == AMSModelOriginType::LITE_EXT) {
|
|
m_panel_lib = new AMSLib(amscan, m_info.ams_id, caninfo, AMSModelOriginType::LITE_EXT);
|
|
}
|
|
else{
|
|
m_panel_lib = new AMSLib(amscan, m_info.ams_id, caninfo);
|
|
}
|
|
|
|
try{
|
|
m_panel_lib->Bind(wxEVT_LEFT_DOWN, [this, canindex](wxMouseEvent& ev) {
|
|
m_canlib_selection = canindex;
|
|
// m_canlib_id = caninfo.can_id;
|
|
|
|
for (auto lib_it : m_can_lib_list) {
|
|
AMSLib* lib = lib_it.second;
|
|
if (lib->m_can_index == m_canlib_selection) {
|
|
wxCommandEvent evt(EVT_AMS_UNSELETED_VAMS);
|
|
evt.SetString(m_info.ams_id);
|
|
wxPostEvent(GetParent()->GetParent(), evt);
|
|
lib->OnSelected();
|
|
}
|
|
else {
|
|
lib->UnSelected();
|
|
}
|
|
}
|
|
ev.Skip();
|
|
});
|
|
|
|
m_panel_lib->m_ams_model = m_ams_model;
|
|
m_panel_lib->m_ams_id = m_info.ams_id;
|
|
m_panel_lib->m_slot_id = caninfo.can_id;
|
|
m_panel_lib->m_info.can_id = caninfo.can_id;
|
|
m_panel_lib->m_can_index = canindex;
|
|
}
|
|
catch (...)
|
|
{
|
|
;
|
|
}
|
|
|
|
//auto m_panel_road = new AMSRoad(amscan, wxID_ANY, caninfo, canindex, maxcan, wxDefaultPosition, AMS_CAN_ROAD_SIZE);
|
|
|
|
if (m_ams_model != AMSModel::AMS_LITE && m_ams_model != AMSModel::EXT_AMS) {
|
|
m_sizer_ams->Add(0, 0, 0, wxALIGN_CENTER_HORIZONTAL, 0);
|
|
m_sizer_ams->Add(m_panel_refresh, 0, wxALIGN_CENTER_HORIZONTAL | wxDOWN, FromDIP(4));
|
|
m_sizer_ams->Add(m_panel_lib, 0, wxALIGN_CENTER_HORIZONTAL, 0);
|
|
}
|
|
else
|
|
{
|
|
if (m_ams_model == AMSModel::EXT_AMS){
|
|
m_sizer_ams->Add(0, 0, 0, wxALIGN_CENTER_HORIZONTAL, 0);
|
|
//m_sizer_ams->Add(m_panel_text, 0, wxALIGN_CENTER_HORIZONTAL | wxTOP, 4);
|
|
m_sizer_ams->Add(m_ext_text, 0, wxALIGN_CENTER_HORIZONTAL | wxDOWN, FromDIP(4));
|
|
m_sizer_ams->Add(m_panel_lib, 0, wxALIGN_CENTER_HORIZONTAL, 0);
|
|
}
|
|
}
|
|
|
|
|
|
amscan->SetSizer(m_sizer_ams);
|
|
amscan->Layout();
|
|
amscan->Fit();
|
|
|
|
sizer->Add(amscan, 0, wxUP | wxLEFT | wxRIGHT, FromDIP(5));
|
|
|
|
m_can_lib_list[caninfo.can_id] = m_panel_lib;
|
|
//m_can_road_list[caninfo.can_id] = m_panel_road;
|
|
}
|
|
|
|
void AmsItem::AddLiteCan(Caninfo caninfo, int canindex, wxGridSizer* sizer)
|
|
{
|
|
auto amscan = new wxWindow(this, wxID_ANY);
|
|
/*amscan->SetSize(wxSize(FromDIP(49), FromDIP(72)));
|
|
amscan->SetMinSize(wxSize(FromDIP(49), FromDIP(72)));
|
|
amscan->SetMaxSize(wxSize(FromDIP(49), FromDIP(72)));*/
|
|
amscan->SetSize(wxSize(FromDIP(80), FromDIP(72)));
|
|
amscan->SetMinSize(wxSize(FromDIP(80), FromDIP(72)));
|
|
amscan->SetMaxSize(wxSize(FromDIP(80), FromDIP(72)));
|
|
|
|
amscan->SetBackgroundColour(StateColor::darkModeColorFor(AMS_CONTROL_DEF_LIB_BK_COLOUR));
|
|
|
|
wxBoxSizer* m_sizer_ams = new wxBoxSizer(wxHORIZONTAL);
|
|
|
|
auto m_panel_lib = new AMSLib(amscan, m_info.ams_id, caninfo);
|
|
|
|
m_panel_lib->Bind(wxEVT_LEFT_DOWN, [this, canindex](wxMouseEvent& ev) {
|
|
m_canlib_selection = canindex;
|
|
// m_canlib_id = caninfo.can_id;
|
|
|
|
for (auto lib_it : m_can_lib_list) {
|
|
AMSLib* lib = lib_it.second;
|
|
if (lib->m_can_index == m_canlib_selection) {
|
|
wxCommandEvent evt(EVT_AMS_UNSELETED_VAMS);
|
|
evt.SetString(m_info.ams_id);
|
|
wxPostEvent(GetParent()->GetParent(), evt);
|
|
lib->OnSelected();
|
|
}
|
|
else {
|
|
lib->UnSelected();
|
|
}
|
|
}
|
|
ev.Skip();
|
|
});
|
|
|
|
auto ams_refresh = new AMSrefresh(amscan, m_info.ams_id, canindex, caninfo);
|
|
m_can_refresh_list[caninfo.can_id] = ams_refresh;
|
|
m_panel_lib->m_ams_model = m_ams_model;
|
|
m_panel_lib->m_ams_id = m_info.ams_id;
|
|
m_panel_lib->m_slot_id = caninfo.can_id;
|
|
m_panel_lib->m_info.can_id = caninfo.can_id;
|
|
m_panel_lib->m_can_index = canindex;
|
|
|
|
//auto m_panel_road = new AMSRoad(amscan, wxID_ANY, caninfo, canindex, maxcan, wxDefaultPosition, AMS_CAN_ROAD_SIZE);
|
|
if (caninfo.can_id == "0" || caninfo.can_id == "1") {
|
|
m_sizer_ams->Add(ams_refresh, 0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL, 0);
|
|
}
|
|
switch (canindex){
|
|
case 0:
|
|
m_sizer_ams->Add(m_panel_lib, 0, wxALIGN_RIGHT | wxALIGN_BOTTOM, 0);
|
|
break;
|
|
case 1:
|
|
m_sizer_ams->Add(m_panel_lib, 0, wxALIGN_RIGHT | wxALIGN_TOP, 0);
|
|
break;
|
|
case 2:
|
|
m_sizer_ams->Add(m_panel_lib, 0, wxALIGN_LEFT | wxALIGN_TOP, 0);
|
|
break;
|
|
case 3:
|
|
m_sizer_ams->Add(m_panel_lib, 0, wxALIGN_LEFT | wxALIGN_BOTTOM, 0);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
if (caninfo.can_id == "2" || caninfo.can_id == "3") {
|
|
m_sizer_ams->Add(ams_refresh, 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL, 0);
|
|
}
|
|
amscan->SetSizer(m_sizer_ams);
|
|
amscan->Layout();
|
|
amscan->Fit();
|
|
|
|
sizer->Add(amscan, 0, wxUP | wxLEFT | wxRIGHT, FromDIP(5));
|
|
|
|
m_can_lib_list[caninfo.can_id] = m_panel_lib;
|
|
//m_can_road_list[caninfo.can_id] = m_panel_road;
|
|
}
|
|
|
|
void AmsItem::Update(AMSinfo info)
|
|
{
|
|
if (m_info == info)
|
|
{
|
|
return;
|
|
}
|
|
|
|
m_info = info;
|
|
m_can_count = info.cans.size();
|
|
|
|
|
|
// for (auto refresh_it : m_can_refresh_list) {
|
|
// int i = 0;
|
|
// AMSrefresh *refresh = refresh_it.second;
|
|
// if (i < m_can_count) {
|
|
// refresh->Update(info.ams_id, info.cans[i]);
|
|
// refresh->Show();
|
|
// } else {
|
|
// refresh->Hide();
|
|
// }
|
|
// i++;
|
|
// }
|
|
|
|
for (int i = 0; i < m_can_count; i++) {
|
|
auto it = m_can_refresh_list.find(std::to_string(i));
|
|
if (it == m_can_refresh_list.end()) break;
|
|
|
|
auto refresh = it->second;
|
|
if (refresh != nullptr){
|
|
refresh->Update(info.ams_id, info.cans[i]);
|
|
refresh->Show();
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < m_can_lib_list.size(); i++) {
|
|
AMSLib* lib = m_can_lib_list[std::to_string(i)];
|
|
if (lib != nullptr){
|
|
if (i < m_can_count){
|
|
lib->Update(info.cans[i], info.ams_id);
|
|
lib->Show();
|
|
}
|
|
else{
|
|
lib->Hide();
|
|
}
|
|
}
|
|
}
|
|
if (m_panel_road != nullptr){
|
|
m_panel_road->Update(m_info);
|
|
}
|
|
|
|
if (true || m_ams_model == AMSModel::GENERIC_AMS) {
|
|
/*m_panel_road->Update(m_info, info.cans[0]);
|
|
m_panel_road->Show();*/
|
|
}
|
|
Layout();
|
|
}
|
|
|
|
void AmsItem::SetDefSelectCan()
|
|
{
|
|
for (auto lib_it : m_can_lib_list) {
|
|
AMSLib* lib = lib_it.second;
|
|
m_canlib_selection =lib->m_can_index;
|
|
m_canlib_id = lib->m_info.can_id;
|
|
SelectCan(m_canlib_id);
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
void AmsItem::SelectCan(std::string canid)
|
|
{
|
|
for (auto lib_it : m_can_lib_list) {
|
|
AMSLib* lib = lib_it.second;
|
|
if (lib->m_info.can_id == canid) {
|
|
m_canlib_selection = lib->m_can_index;
|
|
}
|
|
}
|
|
|
|
m_canlib_id = canid;
|
|
|
|
for (auto lib_it : m_can_lib_list) {
|
|
AMSLib* lib = lib_it.second;
|
|
if (lib->m_info.can_id == m_canlib_id) {
|
|
wxCommandEvent evt(EVT_AMS_UNSELETED_VAMS);
|
|
evt.SetString(m_info.ams_id);
|
|
wxPostEvent(GetParent()->GetParent(), evt);
|
|
lib->OnSelected();
|
|
} else {
|
|
lib->UnSelected();
|
|
}
|
|
}
|
|
}
|
|
|
|
wxColour AmsItem::GetTagColr(wxString canid)
|
|
{
|
|
auto tag_colour = *wxWHITE;
|
|
for (auto lib_it : m_can_lib_list) {
|
|
AMSLib* lib = lib_it.second;
|
|
if (canid == lib->m_info.can_id) tag_colour = lib->GetLibColour();
|
|
}
|
|
return tag_colour;
|
|
}
|
|
|
|
void AmsItem::SetAmsStepExtra(wxString canid, AMSPassRoadType type, AMSPassRoadSTEP step)
|
|
{
|
|
if (step == AMSPassRoadSTEP::AMS_ROAD_STEP_COMBO_LOAD_STEP1 || step == AMSPassRoadSTEP::AMS_ROAD_STEP_1) {
|
|
SetAmsStep(canid.ToStdString());
|
|
}else if (step == AMSPassRoadSTEP::AMS_ROAD_STEP_COMBO_LOAD_STEP2 || step == AMSPassRoadSTEP::AMS_ROAD_STEP_2) {
|
|
SetAmsStep(canid.ToStdString());
|
|
}else if (step == AMSPassRoadSTEP::AMS_ROAD_STEP_COMBO_LOAD_STEP3 || step == AMSPassRoadSTEP::AMS_ROAD_STEP_3) {
|
|
SetAmsStep(canid.ToStdString());
|
|
}else if (step == AMSPassRoadSTEP::AMS_ROAD_STEP_NONE) {
|
|
SetAmsStep("");
|
|
}
|
|
}
|
|
|
|
void AmsItem::SetAmsStep(std::string amsid, std::string canid, AMSPassRoadType type, AMSPassRoadSTEP step)
|
|
{
|
|
if (m_panel_road){
|
|
m_panel_road->UpdatePassRoad(amsid, canid, type, step);
|
|
}
|
|
if (m_info.ams_id != amsid){
|
|
return;
|
|
}
|
|
|
|
SetAmsStepExtra(canid, type, step);
|
|
/*if (m_info.ams_type == AMSModel::EXTRA_AMS){
|
|
SetAmsStepExtra(canid, type, step);
|
|
}*/
|
|
|
|
/*if (step == AMSPassRoadSTEP::AMS_ROAD_STEP_NONE){
|
|
m_road_canid = "";
|
|
}
|
|
else{
|
|
m_road_canid = canid;
|
|
}*/
|
|
|
|
}
|
|
|
|
//void AmsItem::SetAmsStep(wxString amsid, wxString canid, AMSPassRoadType type, AMSPassRoadSTEP step)
|
|
//{
|
|
//
|
|
// if (step == AMSPassRoadSTEP::AMS_ROAD_STEP_NONE) {
|
|
// for (auto road_it : m_can_road_list) {
|
|
// AMSRoad* road = road_it.second;
|
|
// auto pr = std::vector<AMSPassRoadMode>{};
|
|
// pr.push_back(AMSPassRoadMode::AMS_ROAD_MODE_NONE);
|
|
// road->OnPassRoad(pr);
|
|
// }
|
|
//
|
|
// return;
|
|
// }
|
|
//
|
|
//
|
|
// auto tag_can_index = -1;
|
|
// for (auto road_it : m_can_road_list) {
|
|
// AMSRoad* road = road_it.second;
|
|
// if (canid == road->m_info.can_id) { tag_can_index = road->m_canindex; }
|
|
// }
|
|
// if (tag_can_index == -1) return;
|
|
//
|
|
// // get colour
|
|
// auto tag_colour = *wxWHITE;
|
|
// for (auto lib_it : m_can_lib_list) {
|
|
// AMSLib* lib = lib_it.second;
|
|
// if (canid == lib->m_info.can_id) tag_colour = lib->GetLibColour();
|
|
// }
|
|
//
|
|
// // unload
|
|
// if (type == AMSPassRoadType::AMS_ROAD_TYPE_UNLOAD) {
|
|
// for (auto road_it : m_can_road_list) {
|
|
// AMSRoad* road = road_it.second;
|
|
//
|
|
// auto index = road->m_canindex;
|
|
// auto pr = std::vector<AMSPassRoadMode>{};
|
|
//
|
|
// pr.push_back(AMSPassRoadMode::AMS_ROAD_MODE_END_BOTTOM);
|
|
// if (step == AMSPassRoadSTEP::AMS_ROAD_STEP_2) { pr.push_back(AMSPassRoadMode::AMS_ROAD_MODE_END_BOTTOM); }
|
|
//
|
|
// if (step == AMSPassRoadSTEP::AMS_ROAD_STEP_3) {
|
|
// if (index == tag_can_index && index > 0) { pr.push_back(AMSPassRoadMode::AMS_ROAD_MODE_LEFT); }
|
|
// if (index < tag_can_index && index > 0) { pr.push_back(AMSPassRoadMode::AMS_ROAD_MODE_LEFT_RIGHT); }
|
|
// if (index == 0 && tag_can_index == index) { pr.push_back(AMSPassRoadMode::AMS_ROAD_MODE_END_TOP); }
|
|
// if (index == 0 && tag_can_index > index) { pr.push_back(AMSPassRoadMode::AMS_ROAD_MODE_END_RIGHT); }
|
|
// }
|
|
//
|
|
// road->SetPassRoadColour(tag_colour);
|
|
// road->OnPassRoad(pr);
|
|
// }
|
|
// }
|
|
//
|
|
// // load
|
|
// if (type == AMSPassRoadType::AMS_ROAD_TYPE_LOAD) {
|
|
// for (auto road_it : m_can_road_list) {
|
|
// AMSRoad* road = road_it.second;
|
|
//
|
|
// auto index = road->m_canindex;
|
|
// auto pr = std::vector<AMSPassRoadMode>{};
|
|
//
|
|
// if (index == tag_can_index && index > 0) { pr.push_back(AMSPassRoadMode::AMS_ROAD_MODE_LEFT); }
|
|
// if (index < tag_can_index && index > 0) { pr.push_back(AMSPassRoadMode::AMS_ROAD_MODE_LEFT_RIGHT); }
|
|
// if (index == 0 && tag_can_index == index) { pr.push_back(AMSPassRoadMode::AMS_ROAD_MODE_END_TOP); }
|
|
// if (index == 0 && tag_can_index > index) { pr.push_back(AMSPassRoadMode::AMS_ROAD_MODE_END_RIGHT); }
|
|
//
|
|
// if (step == AMSPassRoadSTEP::AMS_ROAD_STEP_2) { pr.push_back(AMSPassRoadMode::AMS_ROAD_MODE_END_BOTTOM); }
|
|
//
|
|
// road->SetPassRoadColour(tag_colour);
|
|
// road->OnPassRoad(pr);
|
|
// }
|
|
// }
|
|
//}
|
|
|
|
void AmsItem::SetAmsStep(std::string can_id)
|
|
{
|
|
if (m_road_canid != can_id) {
|
|
m_road_canid = can_id;
|
|
Refresh();
|
|
}
|
|
for (auto lib : m_can_lib_list){
|
|
if (lib.second->m_info.can_id == can_id){
|
|
lib.second->on_pass_road(true);
|
|
}
|
|
else{
|
|
lib.second->on_pass_road(false);
|
|
}
|
|
}
|
|
}
|
|
|
|
void AmsItem::PlayRridLoading(wxString canid)
|
|
{
|
|
for (auto refresh_it : m_can_refresh_list) {
|
|
AMSrefresh* refresh = refresh_it.second;
|
|
if (refresh->GetCanId() == canid) { refresh->PlayLoading(); }
|
|
}
|
|
}
|
|
|
|
std::string AmsItem::GetCurrentCan()
|
|
{
|
|
if (m_canlib_selection < 0)
|
|
return "";
|
|
|
|
return wxString::Format("%d", m_canlib_selection).ToStdString();
|
|
}
|
|
|
|
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();
|
|
|
|
//road for extra
|
|
if (m_ams_model == AMSModel::AMS_LITE) {
|
|
dc.DrawBitmap(m_bitmap_extra_framework.bmp(), (size.x - m_bitmap_extra_framework.GetBmpSize().x) / 2, (size.y - m_bitmap_extra_framework.GetBmpSize().y) / 2 - FromDIP(4));
|
|
|
|
// A1
|
|
dc.SetPen(wxPen(AMS_CONTROL_GRAY500, 2, wxPENSTYLE_SOLID));
|
|
dc.SetBrush(wxBrush(*wxTRANSPARENT_BRUSH));
|
|
RenderLiteRoad(dc, size);
|
|
}
|
|
}
|
|
|
|
void AmsItem::RenderLiteRoad(wxDC& dc, wxSize size) {
|
|
auto end_top = size.x - FromDIP(3);
|
|
if (m_panel_pos == AMSPanelPos::RIGHT_PANEL){
|
|
end_top = 0;
|
|
}
|
|
auto passroad_width = 4;
|
|
auto a1_top = m_panel_pos == AMSPanelPos::RIGHT_PANEL ? size.y / 2 - FromDIP(4) : size.y / 2;
|
|
auto a2_top = m_panel_pos == AMSPanelPos::RIGHT_PANEL ? size.y / 2 : size.y / 2 - FromDIP(4);
|
|
auto a3_top = m_panel_pos == AMSPanelPos::RIGHT_PANEL ? size.y / 2 + FromDIP(8) : size.y / 2 + FromDIP(4);
|
|
auto a4_top = m_panel_pos == AMSPanelPos::RIGHT_PANEL ? size.y / 2 + FromDIP(4) : size.y / 2 + FromDIP(8);
|
|
|
|
try
|
|
{
|
|
auto a1_left = m_can_lib_list["0"]->GetScreenPosition().x + m_can_lib_list["0"]->GetSize().x / 2;
|
|
auto local_pos1 = GetScreenPosition().x + GetSize().x / 2;
|
|
a1_left = size.x / 2 + (a1_left - local_pos1);
|
|
dc.DrawLine(a1_left, FromDIP(30), a1_left, a1_top);
|
|
dc.DrawLine(a1_left, a1_top, end_top, a1_top);
|
|
|
|
// A2
|
|
auto a2_left = m_can_lib_list["3"]->GetScreenPosition().x + m_can_lib_list["3"]->GetSize().x / 2;
|
|
auto local_pos2 = GetScreenPosition().x + GetSize().x / 2;
|
|
a2_left = size.x / 2 + (a2_left - local_pos2);
|
|
dc.DrawLine(a2_left, FromDIP(30), a2_left, a2_top);
|
|
dc.DrawLine(a2_left, a2_top, end_top, a2_top);
|
|
|
|
// A3
|
|
auto a3_left = m_can_lib_list["1"]->GetScreenPosition().x + m_can_lib_list["1"]->GetSize().x / 2;
|
|
auto local_pos3 = GetScreenPosition().x + GetSize().x / 2;
|
|
a3_left = size.x / 2 + (a3_left - local_pos3);
|
|
dc.DrawLine(a3_left, FromDIP(160), a3_left, a3_top);
|
|
dc.DrawLine(a3_left, a3_top, end_top, a3_top);
|
|
|
|
|
|
//// A4
|
|
auto a4_left = m_can_lib_list["2"]->GetScreenPosition().x + m_can_lib_list["2"]->GetSize().x / 2;
|
|
auto local_pos4 = GetScreenPosition().x + GetSize().x / 2;
|
|
a4_left = size.x / 2 + (a4_left - local_pos4);
|
|
dc.DrawLine(a4_left, FromDIP(160), a4_left, a4_top);
|
|
dc.DrawLine(a4_left, a4_top, end_top, a4_top);
|
|
|
|
//to Extruder
|
|
dc.SetPen(wxPen(AMS_CONTROL_GRAY500, 2, wxPENSTYLE_SOLID));
|
|
dc.SetBrush(wxBrush(*wxTRANSPARENT_BRUSH));
|
|
auto top = std::min(a1_top, a2_top);
|
|
dc.DrawLine(end_top, top, end_top, size.y);
|
|
|
|
|
|
if (!m_road_canid.empty()) {
|
|
int can_idx = atoi(m_road_canid.c_str());
|
|
if (can_idx < 0 || can_idx >= m_info.cans.size()) {
|
|
return;
|
|
}
|
|
m_road_colour = m_info.cans[can_idx].material_colour;
|
|
dc.SetPen(wxPen(m_road_colour, passroad_width, wxPENSTYLE_SOLID));
|
|
if (m_road_canid == "0") {
|
|
dc.DrawLine(a1_left, FromDIP(30), a1_left, a1_top);
|
|
dc.DrawLine(a1_left, a1_top, end_top, a1_top);
|
|
dc.DrawLine(end_top, a1_top, end_top, size.y);
|
|
}
|
|
|
|
if (m_road_canid == "3") {
|
|
dc.DrawLine(a2_left, FromDIP(30), a2_left, a2_top);
|
|
dc.DrawLine(a2_left, a2_top, end_top, a2_top);
|
|
dc.DrawLine(end_top, a2_top, end_top, size.y);
|
|
}
|
|
|
|
if (m_road_canid == "1") {
|
|
dc.DrawLine(a3_left, FromDIP(160), a3_left, a3_top);
|
|
dc.DrawLine(a3_left, a3_top, end_top, a3_top);
|
|
dc.DrawLine(end_top, a3_top, end_top, size.y);
|
|
}
|
|
|
|
if (m_road_canid == "2") {
|
|
dc.DrawLine(a4_left, FromDIP(160), a4_left, a4_top);
|
|
dc.DrawLine(a4_left, a4_top, end_top, a4_top);
|
|
dc.DrawLine(end_top, a4_top, end_top, size.y);
|
|
}
|
|
}
|
|
}
|
|
catch (...) {}
|
|
}
|
|
|
|
void AmsItem::StopRridLoading(wxString canid)
|
|
{
|
|
for (auto refresh_it : m_can_refresh_list) {
|
|
AMSrefresh* refresh = refresh_it.second;
|
|
if (refresh->GetCanId() == canid) { refresh->StopLoading(); }
|
|
}
|
|
}
|
|
|
|
void AmsItem::msw_rescale()
|
|
{
|
|
for (auto refresh_it : m_can_refresh_list) {
|
|
AMSrefresh* refresh = refresh_it.second;
|
|
if(refresh) refresh->msw_rescale();
|
|
}
|
|
|
|
for (auto lib_it : m_can_lib_list) {
|
|
AMSLib* lib = lib_it.second;
|
|
if (lib) lib->msw_rescale();
|
|
}
|
|
if (m_humidity != nullptr) m_humidity->msw_rescale();
|
|
if (m_ext_text != nullptr) m_ext_text->msw_rescale();
|
|
if (m_ext_image != nullptr) m_ext_image->msw_rescale(); //ext image upon the lib
|
|
|
|
m_bitmap_extra_framework = ScalableBitmap(this, "ams_extra_framework_mid_new", 134);
|
|
|
|
Layout();
|
|
Refresh();
|
|
}
|
|
|
|
void AmsItem::show_sn_value(bool show)
|
|
{
|
|
for (auto lib_it : m_can_lib_list) {
|
|
AMSLib* lib = lib_it.second;
|
|
if (lib) lib->show_kn_value(show);
|
|
}
|
|
}
|
|
|
|
}} // namespace Slic3r::GUI
|