871 lines
29 KiB
C++
871 lines
29 KiB
C++
#include "libslic3r/libslic3r.h"
|
|
#include "libslic3r/GCode/PreviewData.hpp"
|
|
#include "GUI_Preview.hpp"
|
|
#include "GUI_App.hpp"
|
|
#include "GUI.hpp"
|
|
#include "I18N.hpp"
|
|
#include "AppConfig.hpp"
|
|
#include "3DScene.hpp"
|
|
#include "BackgroundSlicingProcess.hpp"
|
|
#include "GLCanvas3DManager.hpp"
|
|
#include "GLCanvas3D.hpp"
|
|
#include "PresetBundle.hpp"
|
|
#include "wxExtensions.hpp"
|
|
|
|
#include <wx/notebook.h>
|
|
#include <wx/glcanvas.h>
|
|
#include <wx/sizer.h>
|
|
#include <wx/stattext.h>
|
|
#include <wx/choice.h>
|
|
#include <wx/combo.h>
|
|
#include <wx/checkbox.h>
|
|
|
|
// this include must follow the wxWidgets ones or it won't compile on Windows -> see http://trac.wxwidgets.org/ticket/2421
|
|
#include "libslic3r/Print.hpp"
|
|
#include "libslic3r/SLAPrint.hpp"
|
|
|
|
namespace Slic3r {
|
|
namespace GUI {
|
|
|
|
View3D::View3D(wxWindow* parent, Model* model, DynamicPrintConfig* config, BackgroundSlicingProcess* process)
|
|
: m_canvas_widget(nullptr)
|
|
, m_canvas(nullptr)
|
|
#if !ENABLE_IMGUI
|
|
, m_gizmo_widget(nullptr)
|
|
#endif // !ENABLE_IMGUI
|
|
, m_model(nullptr)
|
|
, m_config(nullptr)
|
|
, m_process(nullptr)
|
|
{
|
|
init(parent, model, config, process);
|
|
}
|
|
|
|
View3D::~View3D()
|
|
{
|
|
if (m_canvas_widget != nullptr)
|
|
{
|
|
_3DScene::remove_canvas(m_canvas_widget);
|
|
delete m_canvas_widget;
|
|
m_canvas = nullptr;
|
|
}
|
|
}
|
|
|
|
bool View3D::init(wxWindow* parent, Model* model, DynamicPrintConfig* config, BackgroundSlicingProcess* process)
|
|
{
|
|
if (!Create(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize))
|
|
return false;
|
|
|
|
m_canvas_widget = GLCanvas3DManager::create_wxglcanvas(this);
|
|
_3DScene::add_canvas(m_canvas_widget);
|
|
m_canvas = _3DScene::get_canvas(this->m_canvas_widget);
|
|
|
|
m_canvas->allow_multisample(GLCanvas3DManager::can_multisample());
|
|
// XXX: If have OpenGL
|
|
m_canvas->enable_picking(true);
|
|
m_canvas->enable_moving(true);
|
|
// XXX: more config from 3D.pm
|
|
m_canvas->set_model(model);
|
|
m_canvas->set_process(process);
|
|
m_canvas->set_config(config);
|
|
m_canvas->enable_gizmos(true);
|
|
m_canvas->enable_toolbar(true);
|
|
|
|
#if !ENABLE_IMGUI
|
|
m_gizmo_widget = new wxPanel(this, wxID_ANY, wxDefaultPosition, wxDefaultSize);
|
|
m_gizmo_widget->SetSizer(new wxBoxSizer(wxVERTICAL));
|
|
m_canvas->set_external_gizmo_widgets_parent(m_gizmo_widget);
|
|
#endif // !ENABLE_IMGUI
|
|
|
|
wxBoxSizer* main_sizer = new wxBoxSizer(wxVERTICAL);
|
|
main_sizer->Add(m_canvas_widget, 1, wxALL | wxEXPAND, 0);
|
|
#if !ENABLE_IMGUI
|
|
main_sizer->Add(m_gizmo_widget, 0, wxALL | wxEXPAND, 0);
|
|
#endif // !ENABLE_IMGUI
|
|
|
|
SetSizer(main_sizer);
|
|
SetMinSize(GetSize());
|
|
GetSizer()->SetSizeHints(this);
|
|
|
|
return true;
|
|
}
|
|
|
|
void View3D::set_bed(Bed3D* bed)
|
|
{
|
|
if (m_canvas != nullptr)
|
|
m_canvas->set_bed(bed);
|
|
}
|
|
|
|
void View3D::set_view_toolbar(GLToolbar* toolbar)
|
|
{
|
|
if (m_canvas != nullptr)
|
|
m_canvas->set_view_toolbar(toolbar);
|
|
}
|
|
|
|
void View3D::set_as_dirty()
|
|
{
|
|
if (m_canvas != nullptr)
|
|
m_canvas->set_as_dirty();
|
|
}
|
|
|
|
void View3D::bed_shape_changed()
|
|
{
|
|
if (m_canvas != nullptr)
|
|
m_canvas->bed_shape_changed();
|
|
}
|
|
|
|
void View3D::select_view(const std::string& direction)
|
|
{
|
|
if (m_canvas != nullptr)
|
|
m_canvas->select_view(direction);
|
|
}
|
|
|
|
void View3D::select_all()
|
|
{
|
|
if (m_canvas != nullptr)
|
|
m_canvas->select_all();
|
|
}
|
|
|
|
void View3D::delete_selected()
|
|
{
|
|
if (m_canvas != nullptr)
|
|
m_canvas->delete_selected();
|
|
}
|
|
|
|
void View3D::mirror_selection(Axis axis)
|
|
{
|
|
if (m_canvas != nullptr)
|
|
m_canvas->mirror_selection(axis);
|
|
}
|
|
|
|
#if ENABLE_MODE_AWARE_TOOLBAR_ITEMS
|
|
void View3D::update_toolbar_items_visibility()
|
|
{
|
|
if (m_canvas != nullptr)
|
|
m_canvas->update_toolbar_items_visibility();
|
|
}
|
|
#endif // ENABLE_MODE_AWARE_TOOLBAR_ITEMS
|
|
|
|
void View3D::enable_toolbar_item(const std::string& name, bool enable)
|
|
{
|
|
if (m_canvas != nullptr)
|
|
m_canvas->enable_toolbar_item(name, enable);
|
|
}
|
|
|
|
int View3D::check_volumes_outside_state() const
|
|
{
|
|
return (m_canvas != nullptr) ? m_canvas->check_volumes_outside_state() : false;
|
|
}
|
|
|
|
bool View3D::is_layers_editing_enabled() const
|
|
{
|
|
return (m_canvas != nullptr) ? m_canvas->is_layers_editing_enabled() : false;
|
|
}
|
|
|
|
bool View3D::is_layers_editing_allowed() const
|
|
{
|
|
return (m_canvas != nullptr) ? m_canvas->is_layers_editing_allowed() : false;
|
|
}
|
|
|
|
void View3D::enable_layers_editing(bool enable)
|
|
{
|
|
if (m_canvas != nullptr)
|
|
m_canvas->enable_layers_editing(enable);
|
|
}
|
|
|
|
bool View3D::is_dragging() const
|
|
{
|
|
return (m_canvas != nullptr) ? m_canvas->is_dragging() : false;
|
|
}
|
|
|
|
bool View3D::is_reload_delayed() const
|
|
{
|
|
return (m_canvas != nullptr) ? m_canvas->is_reload_delayed() : false;
|
|
}
|
|
|
|
void View3D::reload_scene(bool refresh_immediately, bool force_full_scene_refresh)
|
|
{
|
|
if (m_canvas != nullptr)
|
|
m_canvas->reload_scene(refresh_immediately, force_full_scene_refresh);
|
|
}
|
|
|
|
void View3D::render()
|
|
{
|
|
if (m_canvas != nullptr)
|
|
m_canvas->render();
|
|
}
|
|
|
|
Preview::Preview(wxWindow* parent, DynamicPrintConfig* config, BackgroundSlicingProcess* process, GCodePreviewData* gcode_preview_data, std::function<void()> schedule_background_process_func)
|
|
: m_canvas_widget(nullptr)
|
|
, m_canvas(nullptr)
|
|
, m_double_slider_sizer(nullptr)
|
|
, m_label_view_type(nullptr)
|
|
, m_choice_view_type(nullptr)
|
|
, m_label_show_features(nullptr)
|
|
, m_combochecklist_features(nullptr)
|
|
, m_checkbox_travel(nullptr)
|
|
, m_checkbox_retractions(nullptr)
|
|
, m_checkbox_unretractions(nullptr)
|
|
, m_checkbox_shells(nullptr)
|
|
, m_config(config)
|
|
, m_process(process)
|
|
, m_gcode_preview_data(gcode_preview_data)
|
|
, m_number_extruders(1)
|
|
, m_preferred_color_mode("feature")
|
|
, m_loaded(false)
|
|
, m_enabled(false)
|
|
, m_schedule_background_process(schedule_background_process_func)
|
|
{
|
|
if (init(parent, config, process, gcode_preview_data))
|
|
{
|
|
show_hide_ui_elements("none");
|
|
load_print();
|
|
}
|
|
}
|
|
|
|
bool Preview::init(wxWindow* parent, DynamicPrintConfig* config, BackgroundSlicingProcess* process, GCodePreviewData* gcode_preview_data)
|
|
{
|
|
if ((config == nullptr) || (process == nullptr) || (gcode_preview_data == nullptr))
|
|
return false;
|
|
|
|
if (!Create(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize))
|
|
return false;
|
|
|
|
m_canvas_widget = GLCanvas3DManager::create_wxglcanvas(this);
|
|
_3DScene::add_canvas(m_canvas_widget);
|
|
m_canvas = _3DScene::get_canvas(this->m_canvas_widget);
|
|
m_canvas->allow_multisample(GLCanvas3DManager::can_multisample());
|
|
m_canvas->set_config(m_config);
|
|
m_canvas->set_process(process);
|
|
m_canvas->enable_legend_texture(true);
|
|
m_canvas->enable_dynamic_background(true);
|
|
|
|
m_double_slider_sizer = new wxBoxSizer(wxHORIZONTAL);
|
|
create_double_slider();
|
|
|
|
m_label_view_type = new wxStaticText(this, wxID_ANY, _(L("View")));
|
|
|
|
m_choice_view_type = new wxChoice(this, wxID_ANY);
|
|
m_choice_view_type->Append(_(L("Feature type")));
|
|
m_choice_view_type->Append(_(L("Height")));
|
|
m_choice_view_type->Append(_(L("Width")));
|
|
m_choice_view_type->Append(_(L("Speed")));
|
|
m_choice_view_type->Append(_(L("Volumetric flow rate")));
|
|
m_choice_view_type->Append(_(L("Tool")));
|
|
m_choice_view_type->Append(_(L("Color Print")));
|
|
m_choice_view_type->SetSelection(0);
|
|
|
|
m_label_show_features = new wxStaticText(this, wxID_ANY, _(L("Show")));
|
|
|
|
m_combochecklist_features = new wxComboCtrl();
|
|
m_combochecklist_features->Create(this, wxID_ANY, _(L("Feature types")), wxDefaultPosition, wxSize(15 * wxGetApp().em_unit(), -1), wxCB_READONLY);
|
|
std::string feature_text = GUI::into_u8(_(L("Feature types")));
|
|
std::string feature_items = GUI::into_u8(
|
|
_(L("Perimeter")) + "|" +
|
|
_(L("External perimeter")) + "|" +
|
|
_(L("Overhang perimeter")) + "|" +
|
|
_(L("Internal infill")) + "|" +
|
|
_(L("Solid infill")) + "|" +
|
|
_(L("Top solid infill")) + "|" +
|
|
_(L("Bridge infill")) + "|" +
|
|
_(L("Gap fill")) + "|" +
|
|
_(L("Skirt")) + "|" +
|
|
_(L("Support material")) + "|" +
|
|
_(L("Support material interface")) + "|" +
|
|
_(L("Wipe tower")) + "|" +
|
|
_(L("Custom"))
|
|
);
|
|
Slic3r::GUI::create_combochecklist(m_combochecklist_features, feature_text, feature_items, true);
|
|
|
|
m_checkbox_travel = new wxCheckBox(this, wxID_ANY, _(L("Travel")));
|
|
m_checkbox_retractions = new wxCheckBox(this, wxID_ANY, _(L("Retractions")));
|
|
m_checkbox_unretractions = new wxCheckBox(this, wxID_ANY, _(L("Unretractions")));
|
|
m_checkbox_shells = new wxCheckBox(this, wxID_ANY, _(L("Shells")));
|
|
|
|
wxBoxSizer* top_sizer = new wxBoxSizer(wxHORIZONTAL);
|
|
top_sizer->Add(m_canvas_widget, 1, wxALL | wxEXPAND, 0);
|
|
top_sizer->Add(m_double_slider_sizer, 0, wxEXPAND, 0);
|
|
|
|
wxBoxSizer* bottom_sizer = new wxBoxSizer(wxHORIZONTAL);
|
|
bottom_sizer->Add(m_label_view_type, 0, wxALIGN_CENTER_VERTICAL, 5);
|
|
bottom_sizer->Add(m_choice_view_type, 0, wxEXPAND | wxALL, 5);
|
|
bottom_sizer->AddSpacer(10);
|
|
bottom_sizer->Add(m_label_show_features, 0, wxALIGN_CENTER_VERTICAL, 5);
|
|
bottom_sizer->Add(m_combochecklist_features, 0, wxEXPAND | wxALL, 5);
|
|
bottom_sizer->AddSpacer(20);
|
|
bottom_sizer->Add(m_checkbox_travel, 0, wxEXPAND | wxALL, 5);
|
|
bottom_sizer->AddSpacer(10);
|
|
bottom_sizer->Add(m_checkbox_retractions, 0, wxEXPAND | wxALL, 5);
|
|
bottom_sizer->AddSpacer(10);
|
|
bottom_sizer->Add(m_checkbox_unretractions, 0, wxEXPAND | wxALL, 5);
|
|
bottom_sizer->AddSpacer(10);
|
|
bottom_sizer->Add(m_checkbox_shells, 0, wxEXPAND | wxALL, 5);
|
|
|
|
wxBoxSizer* main_sizer = new wxBoxSizer(wxVERTICAL);
|
|
main_sizer->Add(top_sizer, 1, wxALL | wxEXPAND, 0);
|
|
main_sizer->Add(bottom_sizer, 0, wxALL | wxEXPAND, 0);
|
|
|
|
SetSizer(main_sizer);
|
|
SetMinSize(GetSize());
|
|
GetSizer()->SetSizeHints(this);
|
|
|
|
bind_event_handlers();
|
|
|
|
// sets colors for gcode preview extrusion roles
|
|
std::vector<std::string> extrusion_roles_colors = {
|
|
"Perimeter", "FFFF66",
|
|
"External perimeter", "FFA500",
|
|
"Overhang perimeter", "0000FF",
|
|
"Internal infill", "B1302A",
|
|
"Solid infill", "D732D7",
|
|
"Top solid infill", "FF1A1A",
|
|
"Bridge infill", "9999FF",
|
|
"Gap fill", "FFFFFF",
|
|
"Skirt", "845321",
|
|
"Support material", "00FF00",
|
|
"Support material interface", "008000",
|
|
"Wipe tower", "B3E3AB",
|
|
"Custom", "28CC94"
|
|
};
|
|
m_gcode_preview_data->set_extrusion_paths_colors(extrusion_roles_colors);
|
|
|
|
return true;
|
|
}
|
|
|
|
Preview::~Preview()
|
|
{
|
|
unbind_event_handlers();
|
|
|
|
if (m_canvas_widget != nullptr)
|
|
{
|
|
_3DScene::remove_canvas(m_canvas_widget);
|
|
delete m_canvas_widget;
|
|
m_canvas = nullptr;
|
|
}
|
|
}
|
|
|
|
void Preview::set_bed(Bed3D* bed)
|
|
{
|
|
if (m_canvas != nullptr)
|
|
m_canvas->set_bed(bed);
|
|
}
|
|
|
|
void Preview::set_view_toolbar(GLToolbar* toolbar)
|
|
{
|
|
if (m_canvas != nullptr)
|
|
m_canvas->set_view_toolbar(toolbar);
|
|
}
|
|
|
|
void Preview::set_number_extruders(unsigned int number_extruders)
|
|
{
|
|
if (m_number_extruders != number_extruders)
|
|
{
|
|
m_number_extruders = number_extruders;
|
|
int tool_idx = m_choice_view_type->FindString(_(L("Tool")));
|
|
int type = (number_extruders > 1) ? tool_idx /* color by a tool number */ : 0; // color by a feature type
|
|
m_choice_view_type->SetSelection(type);
|
|
if ((0 <= type) && (type < (int)GCodePreviewData::Extrusion::Num_View_Types))
|
|
m_gcode_preview_data->extrusion.view_type = (GCodePreviewData::Extrusion::EViewType)type;
|
|
|
|
m_preferred_color_mode = (type == tool_idx) ? "tool_or_feature" : "feature";
|
|
}
|
|
}
|
|
|
|
void Preview::set_canvas_as_dirty()
|
|
{
|
|
m_canvas->set_as_dirty();
|
|
}
|
|
|
|
void Preview::set_enabled(bool enabled)
|
|
{
|
|
m_enabled = enabled;
|
|
}
|
|
|
|
void Preview::bed_shape_changed()
|
|
{
|
|
if (m_canvas != nullptr)
|
|
m_canvas->bed_shape_changed();
|
|
}
|
|
|
|
void Preview::select_view(const std::string& direction)
|
|
{
|
|
m_canvas->select_view(direction);
|
|
}
|
|
|
|
void Preview::set_viewport_from_scene(GLCanvas3D* canvas)
|
|
{
|
|
if (canvas != nullptr)
|
|
m_canvas->set_viewport_from_scene(*canvas);
|
|
}
|
|
|
|
void Preview::set_viewport_into_scene(GLCanvas3D* canvas)
|
|
{
|
|
if (canvas != nullptr)
|
|
canvas->set_viewport_from_scene(*m_canvas);
|
|
}
|
|
|
|
void Preview::set_drop_target(wxDropTarget* target)
|
|
{
|
|
if (target != nullptr)
|
|
SetDropTarget(target);
|
|
}
|
|
|
|
void Preview::load_print()
|
|
{
|
|
PrinterTechnology tech = m_process->current_printer_technology();
|
|
if (tech == ptFFF)
|
|
load_print_as_fff();
|
|
else if (tech == ptSLA)
|
|
load_print_as_sla();
|
|
}
|
|
|
|
void Preview::reload_print(bool force)
|
|
{
|
|
m_canvas->reset_volumes();
|
|
m_canvas->reset_legend_texture();
|
|
m_loaded = false;
|
|
|
|
if (!IsShown() && !force)
|
|
return;
|
|
|
|
load_print();
|
|
}
|
|
|
|
void Preview::refresh_print()
|
|
{
|
|
m_loaded = false;
|
|
|
|
if (!IsShown())
|
|
return;
|
|
|
|
load_print();
|
|
}
|
|
|
|
void Preview::bind_event_handlers()
|
|
{
|
|
this->Bind(wxEVT_SIZE, &Preview::on_size, this);
|
|
m_choice_view_type->Bind(wxEVT_CHOICE, &Preview::on_choice_view_type, this);
|
|
m_combochecklist_features->Bind(wxEVT_CHECKLISTBOX, &Preview::on_combochecklist_features, this);
|
|
m_checkbox_travel->Bind(wxEVT_CHECKBOX, &Preview::on_checkbox_travel, this);
|
|
m_checkbox_retractions->Bind(wxEVT_CHECKBOX, &Preview::on_checkbox_retractions, this);
|
|
m_checkbox_unretractions->Bind(wxEVT_CHECKBOX, &Preview::on_checkbox_unretractions, this);
|
|
m_checkbox_shells->Bind(wxEVT_CHECKBOX, &Preview::on_checkbox_shells, this);
|
|
}
|
|
|
|
void Preview::unbind_event_handlers()
|
|
{
|
|
this->Unbind(wxEVT_SIZE, &Preview::on_size, this);
|
|
m_choice_view_type->Unbind(wxEVT_CHOICE, &Preview::on_choice_view_type, this);
|
|
m_combochecklist_features->Unbind(wxEVT_CHECKLISTBOX, &Preview::on_combochecklist_features, this);
|
|
m_checkbox_travel->Unbind(wxEVT_CHECKBOX, &Preview::on_checkbox_travel, this);
|
|
m_checkbox_retractions->Unbind(wxEVT_CHECKBOX, &Preview::on_checkbox_retractions, this);
|
|
m_checkbox_unretractions->Unbind(wxEVT_CHECKBOX, &Preview::on_checkbox_unretractions, this);
|
|
m_checkbox_shells->Unbind(wxEVT_CHECKBOX, &Preview::on_checkbox_shells, this);
|
|
}
|
|
|
|
void Preview::show_hide_ui_elements(const std::string& what)
|
|
{
|
|
bool enable = (what == "full");
|
|
m_label_show_features->Enable(enable);
|
|
m_combochecklist_features->Enable(enable);
|
|
m_checkbox_travel->Enable(enable);
|
|
m_checkbox_retractions->Enable(enable);
|
|
m_checkbox_unretractions->Enable(enable);
|
|
m_checkbox_shells->Enable(enable);
|
|
|
|
enable = (what != "none");
|
|
m_label_view_type->Enable(enable);
|
|
m_choice_view_type->Enable(enable);
|
|
|
|
bool visible = (what != "none");
|
|
m_label_show_features->Show(visible);
|
|
m_combochecklist_features->Show(visible);
|
|
m_checkbox_travel->Show(visible);
|
|
m_checkbox_retractions->Show(visible);
|
|
m_checkbox_unretractions->Show(visible);
|
|
m_checkbox_shells->Show(visible);
|
|
m_label_view_type->Show(visible);
|
|
m_choice_view_type->Show(visible);
|
|
}
|
|
|
|
void Preview::reset_sliders()
|
|
{
|
|
m_enabled = false;
|
|
// reset_double_slider();
|
|
m_double_slider_sizer->Hide((size_t)0);
|
|
}
|
|
|
|
void Preview::update_sliders(const std::vector<double>& layers_z)
|
|
{
|
|
m_enabled = true;
|
|
update_double_slider(layers_z);
|
|
m_double_slider_sizer->Show((size_t)0);
|
|
Layout();
|
|
}
|
|
|
|
void Preview::on_size(wxSizeEvent& evt)
|
|
{
|
|
evt.Skip();
|
|
Refresh();
|
|
}
|
|
|
|
void Preview::on_choice_view_type(wxCommandEvent& evt)
|
|
{
|
|
m_preferred_color_mode = (m_choice_view_type->GetStringSelection() == L("Tool")) ? "tool" : "feature";
|
|
int selection = m_choice_view_type->GetCurrentSelection();
|
|
if ((0 <= selection) && (selection < (int)GCodePreviewData::Extrusion::Num_View_Types))
|
|
m_gcode_preview_data->extrusion.view_type = (GCodePreviewData::Extrusion::EViewType)selection;
|
|
|
|
reload_print();
|
|
}
|
|
|
|
void Preview::on_combochecklist_features(wxCommandEvent& evt)
|
|
{
|
|
int flags = Slic3r::GUI::combochecklist_get_flags(m_combochecklist_features);
|
|
m_gcode_preview_data->extrusion.role_flags = (unsigned int)flags;
|
|
refresh_print();
|
|
}
|
|
|
|
void Preview::on_checkbox_travel(wxCommandEvent& evt)
|
|
{
|
|
m_gcode_preview_data->travel.is_visible = m_checkbox_travel->IsChecked();
|
|
refresh_print();
|
|
}
|
|
|
|
void Preview::on_checkbox_retractions(wxCommandEvent& evt)
|
|
{
|
|
m_gcode_preview_data->retraction.is_visible = m_checkbox_retractions->IsChecked();
|
|
refresh_print();
|
|
}
|
|
|
|
void Preview::on_checkbox_unretractions(wxCommandEvent& evt)
|
|
{
|
|
m_gcode_preview_data->unretraction.is_visible = m_checkbox_unretractions->IsChecked();
|
|
refresh_print();
|
|
}
|
|
|
|
void Preview::on_checkbox_shells(wxCommandEvent& evt)
|
|
{
|
|
m_gcode_preview_data->shell.is_visible = m_checkbox_shells->IsChecked();
|
|
refresh_print();
|
|
}
|
|
|
|
void Preview::create_double_slider()
|
|
{
|
|
m_slider = new PrusaDoubleSlider(this, wxID_ANY, 0, 0, 0, 100);
|
|
m_double_slider_sizer->Add(m_slider, 0, wxEXPAND, 0);
|
|
|
|
// sizer, m_canvas_widget
|
|
m_canvas_widget->Bind(wxEVT_KEY_DOWN, &Preview::update_double_slider_from_canvas, this);
|
|
|
|
m_slider->Bind(wxEVT_SCROLL_CHANGED, &Preview::on_sliders_scroll_changed, this);
|
|
|
|
Bind(wxCUSTOMEVT_TICKSCHANGED, [this](wxEvent&) {
|
|
auto& config = wxGetApp().preset_bundle->project_config;
|
|
((config.option<ConfigOptionFloats>("colorprint_heights"))->values) = (m_slider->GetTicksValues());
|
|
m_schedule_background_process();
|
|
bool color_print = !config.option<ConfigOptionFloats>("colorprint_heights")->values.empty();
|
|
int type = m_choice_view_type->FindString(color_print ? _(L("Color Print")) : _(L("Feature type")) );
|
|
if (m_choice_view_type->GetSelection() != type) {
|
|
m_choice_view_type->SetSelection(type);
|
|
if ((0 <= type) && (type < (int)GCodePreviewData::Extrusion::Num_View_Types))
|
|
m_gcode_preview_data->extrusion.view_type = (GCodePreviewData::Extrusion::EViewType)type;
|
|
m_preferred_color_mode = "feature";
|
|
}
|
|
reload_print();
|
|
});
|
|
}
|
|
|
|
// Find an index of a value in a sorted vector, which is in <z-eps, z+eps>.
|
|
// Returns -1 if there is no such member.
|
|
static int find_close_layer_idx(const std::vector<double>& zs, double &z, double eps)
|
|
{
|
|
if (zs.empty())
|
|
return -1;
|
|
auto it_h = std::lower_bound(zs.begin(), zs.end(), z);
|
|
if (it_h == zs.end()) {
|
|
auto it_l = it_h;
|
|
-- it_l;
|
|
if (z - *it_l < eps)
|
|
return int(zs.size() - 1);
|
|
} else if (it_h == zs.begin()) {
|
|
if (*it_h - z < eps)
|
|
return 0;
|
|
} else {
|
|
auto it_l = it_h;
|
|
-- it_l;
|
|
double dist_l = z - *it_l;
|
|
double dist_h = *it_h - z;
|
|
if (std::min(dist_l, dist_h) < eps) {
|
|
return (dist_l < dist_h) ? int(it_l - zs.begin()) : int(it_h - zs.begin());
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
void Preview::update_double_slider(const std::vector<double>& layers_z, bool force_sliders_full_range)
|
|
{
|
|
// Save the initial slider span.
|
|
double z_low = m_slider->GetLowerValueD();
|
|
double z_high = m_slider->GetHigherValueD();
|
|
bool was_empty = m_slider->GetMaxValue() == 0;
|
|
bool span_changed = layers_z.empty() || std::abs(layers_z.back() - m_slider->GetMaxValueD()) > 1e-6;
|
|
force_sliders_full_range |= was_empty | span_changed;
|
|
bool snap_to_min = force_sliders_full_range || m_slider->is_lower_at_min();
|
|
bool snap_to_max = force_sliders_full_range || m_slider->is_higher_at_max();
|
|
|
|
std::vector<std::pair<int, double>> values;
|
|
fill_slider_values(values, layers_z);
|
|
m_slider->SetSliderValues(values);
|
|
assert(m_slider->GetMinValue() == 0);
|
|
m_slider->SetMaxValue(layers_z.empty() ? 0 : layers_z.size() - 1);
|
|
|
|
int idx_low = 0;
|
|
int idx_high = m_slider->GetMaxValue();
|
|
if (! layers_z.empty()) {
|
|
if (! snap_to_min) {
|
|
int idx_new = find_close_layer_idx(layers_z, z_low, 1e-6);
|
|
if (idx_new != -1)
|
|
idx_low = idx_new;
|
|
}
|
|
if (! snap_to_max) {
|
|
int idx_new = find_close_layer_idx(layers_z, z_high, 1e-6);
|
|
if (idx_new != -1)
|
|
idx_high = idx_new;
|
|
}
|
|
}
|
|
m_slider->SetSelectionSpan(idx_low, idx_high);
|
|
|
|
const auto& config = wxGetApp().preset_bundle->project_config;
|
|
const std::vector<double> &ticks_from_config = (config.option<ConfigOptionFloats>("colorprint_heights"))->values;
|
|
m_slider->SetTicksValues(ticks_from_config);
|
|
|
|
bool color_print_enable = (wxGetApp().plater()->printer_technology() == ptFFF);
|
|
if (color_print_enable) {
|
|
const auto& config = wxGetApp().preset_bundle->full_config();
|
|
if (config.opt<ConfigOptionFloats>("nozzle_diameter")->values.size() > 1)
|
|
color_print_enable = false;
|
|
}
|
|
m_slider->EnableTickManipulation(color_print_enable);
|
|
}
|
|
|
|
void Preview::fill_slider_values(std::vector<std::pair<int, double>> &values,
|
|
const std::vector<double> &layers_z)
|
|
{
|
|
values.clear();
|
|
for (int i = 0; i < layers_z.size(); ++i)
|
|
{
|
|
values.push_back(std::pair<int, double>(i + 1, layers_z[i]));
|
|
}
|
|
|
|
// All ticks that would end up outside the slider range should be erased.
|
|
// TODO: this should be placed into more appropriate part of code,
|
|
// this function is e.g. not called when the last object is deleted
|
|
std::vector<double> &ticks_from_config = (wxGetApp().preset_bundle->project_config.option<ConfigOptionFloats>("colorprint_heights"))->values;
|
|
unsigned int old_size = ticks_from_config.size();
|
|
ticks_from_config.erase(std::remove_if(ticks_from_config.begin(), ticks_from_config.end(),
|
|
[values](double val) { return values.back().second < val; }),
|
|
ticks_from_config.end());
|
|
if (ticks_from_config.size() != old_size)
|
|
m_schedule_background_process();
|
|
}
|
|
|
|
void Preview::reset_double_slider()
|
|
{
|
|
m_slider->SetHigherValue(0);
|
|
m_slider->SetLowerValue(0);
|
|
}
|
|
|
|
void Preview::update_double_slider_from_canvas(wxKeyEvent& event)
|
|
{
|
|
if (event.HasModifiers()) {
|
|
event.Skip();
|
|
return;
|
|
}
|
|
|
|
const auto key = event.GetKeyCode();
|
|
|
|
if (key == 'U' || key == 'D') {
|
|
const int new_pos = key == 'U' ? m_slider->GetHigherValue() + 1 : m_slider->GetHigherValue() - 1;
|
|
m_slider->SetHigherValue(new_pos);
|
|
if (event.ShiftDown() || m_slider->is_one_layer()) m_slider->SetLowerValue(m_slider->GetHigherValue());
|
|
}
|
|
else if (key == 'S')
|
|
m_slider->ChangeOneLayerLock();
|
|
else
|
|
event.Skip();
|
|
}
|
|
|
|
void Preview::load_print_as_fff()
|
|
{
|
|
if (m_loaded || m_process->current_printer_technology() != ptFFF)
|
|
return;
|
|
|
|
// we require that there's at least one object and the posSlice step
|
|
// is performed on all of them(this ensures that _shifted_copies was
|
|
// populated and we know the number of layers)
|
|
bool has_layers = false;
|
|
const Print *print = m_process->fff_print();
|
|
if (print->is_step_done(posSlice)) {
|
|
for (const PrintObject* print_object : print->objects())
|
|
if (! print_object->layers().empty()) {
|
|
has_layers = true;
|
|
break;
|
|
}
|
|
}
|
|
if (print->is_step_done(posSupportMaterial)) {
|
|
for (const PrintObject* print_object : print->objects())
|
|
if (! print_object->support_layers().empty()) {
|
|
has_layers = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (! has_layers)
|
|
{
|
|
reset_sliders();
|
|
m_canvas->reset_legend_texture();
|
|
m_canvas_widget->Refresh();
|
|
return;
|
|
}
|
|
|
|
if (m_preferred_color_mode == "tool_or_feature")
|
|
{
|
|
// It is left to Slic3r to decide whether the print shall be colored by the tool or by the feature.
|
|
// Color by feature if it is a single extruder print.
|
|
unsigned int number_extruders = (unsigned int)print->extruders().size();
|
|
int tool_idx = m_choice_view_type->FindString(_(L("Tool")));
|
|
int type = (number_extruders > 1) ? tool_idx /* color by a tool number */ : 0; // color by a feature type
|
|
m_choice_view_type->SetSelection(type);
|
|
if ((0 <= type) && (type < (int)GCodePreviewData::Extrusion::Num_View_Types))
|
|
m_gcode_preview_data->extrusion.view_type = (GCodePreviewData::Extrusion::EViewType)type;
|
|
// If the->SetSelection changed the following line, revert it to "decide yourself".
|
|
m_preferred_color_mode = "tool_or_feature";
|
|
}
|
|
|
|
bool gcode_preview_data_valid = print->is_step_done(psGCodeExport) && ! m_gcode_preview_data->empty();
|
|
// Collect colors per extruder.
|
|
std::vector<std::string> colors;
|
|
std::vector<double> color_print_values = {};
|
|
// set color print values, if it si selected "ColorPrint" view type
|
|
if (m_gcode_preview_data->extrusion.view_type == GCodePreviewData::Extrusion::ColorPrint)
|
|
{
|
|
colors = GCodePreviewData::ColorPrintColors();
|
|
if (! gcode_preview_data_valid) {
|
|
//FIXME accessing full_config() is pretty expensive.
|
|
// Only initialize color_print_values for the initial preview, not for the full preview where the color_print_values is extracted from the G-code.
|
|
const auto& config = wxGetApp().preset_bundle->project_config;
|
|
color_print_values = config.option<ConfigOptionFloats>("colorprint_heights")->values;
|
|
}
|
|
}
|
|
else if (gcode_preview_data_valid || (m_gcode_preview_data->extrusion.view_type == GCodePreviewData::Extrusion::Tool) )
|
|
{
|
|
const ConfigOptionStrings* extruders_opt = dynamic_cast<const ConfigOptionStrings*>(m_config->option("extruder_colour"));
|
|
const ConfigOptionStrings* filamemts_opt = dynamic_cast<const ConfigOptionStrings*>(m_config->option("filament_colour"));
|
|
unsigned int colors_count = std::max((unsigned int)extruders_opt->values.size(), (unsigned int)filamemts_opt->values.size());
|
|
|
|
unsigned char rgb[3];
|
|
for (unsigned int i = 0; i < colors_count; ++i)
|
|
{
|
|
std::string color = m_config->opt_string("extruder_colour", i);
|
|
if (!PresetBundle::parse_color(color, rgb))
|
|
{
|
|
color = m_config->opt_string("filament_colour", i);
|
|
if (!PresetBundle::parse_color(color, rgb))
|
|
color = "#FFFFFF";
|
|
}
|
|
|
|
colors.emplace_back(color);
|
|
}
|
|
color_print_values.clear();
|
|
}
|
|
|
|
if (IsShown())
|
|
{
|
|
if (gcode_preview_data_valid)
|
|
// Load the real G-code preview.
|
|
m_canvas->load_gcode_preview(*m_gcode_preview_data, colors);
|
|
else
|
|
// Load the initial preview based on slices, not the final G-code.
|
|
m_canvas->load_preview(colors, color_print_values);
|
|
show_hide_ui_elements(gcode_preview_data_valid ? "full" : "simple");
|
|
// recalculates zs and update sliders accordingly
|
|
std::vector<double> zs = m_canvas->get_current_print_zs(true);
|
|
if (zs.empty()) {
|
|
// all layers filtered out
|
|
reset_sliders();
|
|
m_canvas_widget->Refresh();
|
|
} else
|
|
update_sliders(zs);
|
|
m_loaded = true;
|
|
}
|
|
}
|
|
|
|
void Preview::load_print_as_sla()
|
|
{
|
|
if (m_loaded || (m_process->current_printer_technology() != ptSLA))
|
|
return;
|
|
|
|
unsigned int n_layers = 0;
|
|
const SLAPrint* print = m_process->sla_print();
|
|
|
|
std::set<double> zs;
|
|
for (const SLAPrintObject* obj : print->objects())
|
|
{
|
|
double shift_z = obj->get_current_elevation();
|
|
if (obj->is_step_done(slaposIndexSlices))
|
|
{
|
|
const SLAPrintObject::SliceIndex& index = obj->get_slice_index();
|
|
for (const SLAPrintObject::SliceIndex::value_type& id : index)
|
|
{
|
|
zs.insert(shift_z + id.first);
|
|
}
|
|
}
|
|
}
|
|
|
|
n_layers = (unsigned int)zs.size();
|
|
if (n_layers == 0)
|
|
{
|
|
reset_sliders();
|
|
m_canvas_widget->Refresh();
|
|
}
|
|
|
|
if (IsShown())
|
|
{
|
|
m_canvas->load_sla_preview();
|
|
show_hide_ui_elements("none");
|
|
|
|
if (n_layers > 0)
|
|
{
|
|
std::vector<double> layer_zs;
|
|
std::copy(zs.begin(), zs.end(), std::back_inserter(layer_zs));
|
|
update_sliders(layer_zs);
|
|
}
|
|
|
|
m_loaded = true;
|
|
}
|
|
}
|
|
|
|
void Preview::on_sliders_scroll_changed(wxEvent& event)
|
|
{
|
|
if (IsShown())
|
|
{
|
|
PrinterTechnology tech = m_process->current_printer_technology();
|
|
if (tech == ptFFF)
|
|
{
|
|
m_canvas->set_toolpaths_range(m_slider->GetLowerValueD() - 1e-6, m_slider->GetHigherValueD() + 1e-6);
|
|
m_canvas_widget->Refresh();
|
|
m_canvas->set_use_clipping_planes(false);
|
|
}
|
|
else if (tech == ptSLA)
|
|
{
|
|
m_canvas->set_clipping_plane(0, GLCanvas3D::ClippingPlane(Vec3d::UnitZ(), -m_slider->GetLowerValueD()));
|
|
m_canvas->set_clipping_plane(1, GLCanvas3D::ClippingPlane(-Vec3d::UnitZ(), m_slider->GetHigherValueD()));
|
|
m_canvas->set_use_clipping_planes(m_slider->GetHigherValue() != 0);
|
|
m_canvas_widget->Refresh();
|
|
}
|
|
}
|
|
}
|
|
|
|
} // namespace GUI
|
|
} // namespace Slic3r
|