#include <src/slic3r/GUI/GUI_Preview.hpp>

Inheritance diagram for Slic3r::GUI::Preview:

Collaboration diagram for Slic3r::GUI::Preview:

Public Types
enum class	OptionType : unsigned int { Travel , Wipe , Retractions , Unretractions , Seams , ToolChanges , ColorChanges , PausePrints , CustomGCodes , CenterOfGravity , Shells , ToolMarker }

Public Member Functions
	Preview (wxWindow parent, Bed3D &bed, Model model, DynamicPrintConfig config, BackgroundSlicingProcess process, GCodeProcessorResult *gcode_result, std::function< void()> schedule_background_process=[]() {})

virtual	~Preview ()

wxGLCanvas *	get_wxglcanvas ()

GLCanvas3D *	get_canvas3d ()

void	set_as_dirty ()

void	bed_shape_changed ()

void	select_view (const std::string &direction)

void	set_drop_target (wxDropTarget *target)

void	load_print (bool keep_z_range=false)

void	reload_print (bool keep_volumes=false)

void	refresh_print ()

void	msw_rescale ()

void	sys_color_changed ()

void	jump_layers_slider (wxKeyEvent &evt)

void	move_layers_slider (wxKeyEvent &evt)

void	edit_layers_slider (wxKeyEvent &evt)

bool	is_loaded () const

void	update_moves_slider ()

void	enable_moves_slider (bool enable)

void	move_moves_slider (wxKeyEvent &evt)

void	hide_layers_slider ()

void	set_keep_current_preview_type (bool value)

void	set_layers_slider_values_range (int bottom, int top)

Private Member Functions
bool	init (wxWindow parent, Bed3D &bed, Model model)

void	bind_event_handlers ()

void	unbind_event_handlers ()

void	on_size (wxSizeEvent &evt)

wxBoxSizer *	create_layers_slider_sizer ()

void	check_layers_slider_values (std::vector< CustomGCode::Item > &ticks_from_model, const std::vector< double > &layers_z)

void	reset_layers_slider ()

void	update_layers_slider (const std::vector< double > &layers_z, bool keep_z_range=false)

void	update_layers_slider_mode ()

void	update_layers_slider_from_canvas (wxKeyEvent &event)

void	load_print_as_fff (bool keep_z_range=false)

void	load_print_as_sla ()

void	on_layers_slider_scroll_changed (wxCommandEvent &event)

void	on_moves_slider_scroll_changed (wxCommandEvent &event)

Private Attributes
wxGLCanvas *	m_canvas_widget { nullptr }

GLCanvas3D *	m_canvas { nullptr }

wxBoxSizer *	m_left_sizer { nullptr }

wxBoxSizer *	m_layers_slider_sizer { nullptr }

wxPanel *	m_bottom_toolbar_panel { nullptr }

DynamicPrintConfig *	m_config

BackgroundSlicingProcess *	m_process

GCodeProcessorResult *	m_gcode_result

std::function< void()>	m_schedule_background_process

unsigned int	m_number_extruders { 1 }

bool	m_keep_current_preview_type { false }

bool	m_loaded { false }

DoubleSlider::Control *	m_layers_slider { nullptr }

DoubleSlider::Control *	m_moves_slider { nullptr }

Detailed Description

Member Enumeration Documentation

◆ OptionType

enum class Slic3r::GUI::Preview::OptionType : unsigned int

strong

Enumerator
Travel
Wipe
Retractions
Unretractions
Seams
ToolChanges
ColorChanges
PausePrints
CustomGCodes
CenterOfGravity
Shells
ToolMarker

    {
        Travel,
        Wipe,
        Retractions,
        Unretractions,
        Seams,
        ToolChanges,
        ColorChanges,
        PausePrints,
        CustomGCodes,
        CenterOfGravity,
        Shells,
        ToolMarker,
    };

Constructor & Destructor Documentation

◆ Preview()

Slic3r::GUI::Preview::Preview	(	wxWindow *	parent,
		Bed3D &	bed,
		Model *	model,
		DynamicPrintConfig *	config,
		BackgroundSlicingProcess *	process,
		GCodeProcessorResult *	gcode_result,
		std::function< void()>	schedule_background_process = `[]() {}`
	)

    : m_config(config)
    , m_process(process)
    , m_gcode_result(gcode_result)
    , m_schedule_background_process(schedule_background_process_func)
{
    if (init(parent, bed, model))
        load_print();
}

References init(), and load_print().

Here is the call graph for this function:

◆ ~Preview()

Slic3r::GUI::Preview::~Preview ( )

virtual

{
    unbind_event_handlers();
 
    if (m_canvas != nullptr)
        delete m_canvas;
 
    if (m_canvas_widget != nullptr)
        delete m_canvas_widget;
}

References m_canvas, m_canvas_widget, and unbind_event_handlers().

Here is the call graph for this function:

Member Function Documentation

◆ bed_shape_changed()

void Slic3r::GUI::Preview::bed_shape_changed ( )

{
    if (m_canvas != nullptr)
        m_canvas->bed_shape_changed();
}

References Slic3r::GUI::GLCanvas3D::bed_shape_changed(), and m_canvas.

Here is the call graph for this function:

◆ bind_event_handlers()

void Slic3r::GUI::Preview::bind_event_handlers ( )

private

{
    Bind(wxEVT_SIZE, &Preview::on_size, this);
    m_moves_slider->Bind(wxEVT_SCROLL_CHANGED, &Preview::on_moves_slider_scroll_changed, this);
}

References m_moves_slider, on_moves_slider_scroll_changed(), and on_size().

Referenced by init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_layers_slider_values()

void Slic3r::GUI::Preview::check_layers_slider_values	(	std::vector< CustomGCode::Item > &	ticks_from_model,
		const std::vector< double > &	layers_z
	)

private

{
    // 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
    unsigned int old_size = ticks_from_model.size();
    ticks_from_model.erase(std::remove_if(ticks_from_model.begin(), ticks_from_model.end(),
                     [layers_z](CustomGCode::Item val)
        {
            auto it = std::lower_bound(layers_z.begin(), layers_z.end(), val.print_z - DoubleSlider::epsilon());
            return it == layers_z.end();
        }),
        ticks_from_model.end());
    if (ticks_from_model.size() != old_size)
        m_schedule_background_process();
}

References m_schedule_background_process.

Referenced by update_layers_slider().

Here is the caller graph for this function:

◆ create_layers_slider_sizer()

wxBoxSizer * Slic3r::GUI::Preview::create_layers_slider_sizer ( )

private

{
    wxBoxSizer* sizer = new wxBoxSizer(wxHORIZONTAL);
    m_layers_slider = new DoubleSlider::Control(this, wxID_ANY, 0, 0, 0, 100);
 
    m_layers_slider->SetDrawMode(wxGetApp().preset_bundle->printers.get_edited_preset().printer_technology() == ptSLA,
        wxGetApp().preset_bundle->prints.get_edited_preset().config.opt_bool("complete_objects"));
    m_layers_slider->enable_action_icon(wxGetApp().is_editor());
 
    sizer->Add(m_layers_slider, 0, wxEXPAND, 0);
 
    // sizer, m_canvas_widget
    m_canvas_widget->Bind(wxEVT_KEY_DOWN, &Preview::update_layers_slider_from_canvas, this);
    m_canvas_widget->Bind(wxEVT_KEY_UP, [this](wxKeyEvent& event) {
        if (event.GetKeyCode() == WXK_SHIFT)
            m_layers_slider->UseDefaultColors(true);
        event.Skip();
        });
 
    m_layers_slider->Bind(wxEVT_SCROLL_CHANGED, &Preview::on_layers_slider_scroll_changed, this);
 
    Bind(DoubleSlider::wxCUSTOMEVT_TICKSCHANGED, [this](wxEvent&) {
        Model& model = wxGetApp().plater()->model();
        model.custom_gcode_per_print_z = m_layers_slider->GetTicksValues();
        m_schedule_background_process();
 
        m_keep_current_preview_type = false;
        reload_print(false);
        });
 
    return sizer;
}

References Slic3r::Model::custom_gcode_per_print_z, Slic3r::DoubleSlider::Control::enable_action_icon(), Slic3r::DoubleSlider::Control::GetTicksValues(), m_canvas_widget, m_keep_current_preview_type, m_layers_slider, m_schedule_background_process, on_layers_slider_scroll_changed(), Slic3r::ptSLA, reload_print(), Slic3r::DoubleSlider::Control::SetDrawMode(), update_layers_slider_from_canvas(), and Slic3r::DoubleSlider::Control::UseDefaultColors().

Referenced by init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ edit_layers_slider()

void Slic3r::GUI::Preview::edit_layers_slider ( wxKeyEvent & evt )

{
    if (m_layers_slider != nullptr) m_layers_slider->OnChar(evt);
}

References m_layers_slider, and Slic3r::DoubleSlider::Control::OnChar().

Here is the call graph for this function:

◆ enable_moves_slider()

void Slic3r::GUI::Preview::enable_moves_slider ( bool enable )

{
    bool render_as_disabled = !enable;
    if (m_moves_slider != nullptr && m_moves_slider->is_rendering_as_disabled() != render_as_disabled) {
        m_moves_slider->set_render_as_disabled(render_as_disabled);
        m_moves_slider->Refresh();
    }
}

References Slic3r::DoubleSlider::Control::is_rendering_as_disabled(), m_moves_slider, and Slic3r::DoubleSlider::Control::set_render_as_disabled().

Here is the call graph for this function:

◆ get_canvas3d()

GLCanvas3D * Slic3r::GUI::Preview::get_canvas3d ( )

inline

127{ return m_canvas; }

References m_canvas.

Referenced by Slic3r::GUI::Plater::priv::is_legend_shown(), msw_rescale(), and Slic3r::GUI::Plater::priv::show_legend().

Here is the caller graph for this function:

◆ get_wxglcanvas()

wxGLCanvas * Slic3r::GUI::Preview::get_wxglcanvas ( )

inline

126{ return m_canvas_widget; }

References m_canvas_widget.

◆ hide_layers_slider()

void Slic3r::GUI::Preview::hide_layers_slider ( )

{
    m_layers_slider_sizer->Hide((size_t)0);
    Layout();
}

References m_layers_slider_sizer.

Referenced by load_print_as_fff(), and load_print_as_sla().

Here is the caller graph for this function:

◆ init()

bool Slic3r::GUI::Preview::init	(	wxWindow *	parent,
		Bed3D &	bed,
		Model *	model
	)

private

{
    if (!Create(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, 0 /* disable wxTAB_TRAVERSAL */))
        return false;
 
    // to match the background of the sliders
#ifdef _WIN32 
    wxGetApp().UpdateDarkUI(this);
#else
    SetBackgroundColour(GetParent()->GetBackgroundColour());
#endif // _WIN32 
 
    m_canvas_widget = OpenGLManager::create_wxglcanvas(*this);
    if (m_canvas_widget == nullptr)
        return false;
 
    m_canvas = new GLCanvas3D(m_canvas_widget, bed);
    m_canvas->set_context(wxGetApp().init_glcontext(*m_canvas_widget));
    m_canvas->allow_multisample(OpenGLManager::can_multisample());
    m_canvas->set_config(m_config);
    m_canvas->set_model(model);
    m_canvas->set_process(m_process);
    m_canvas->enable_legend_texture(true);
    m_canvas->enable_dynamic_background(true);
 
    m_layers_slider_sizer = create_layers_slider_sizer();
 
    wxGetApp().UpdateDarkUI(m_bottom_toolbar_panel = new wxPanel(this));
 
    m_left_sizer = new wxBoxSizer(wxVERTICAL);
    m_left_sizer->Add(m_canvas_widget, 1, wxALL | wxEXPAND, 0);
 
    wxBoxSizer* right_sizer = new wxBoxSizer(wxVERTICAL);
    right_sizer->Add(m_layers_slider_sizer, 1, wxEXPAND, 0);
 
    m_moves_slider = new DoubleSlider::Control(m_bottom_toolbar_panel, wxID_ANY, 0, 0, 0, 100, wxDefaultPosition, wxDefaultSize, wxSL_HORIZONTAL);
    m_moves_slider->SetDrawMode(DoubleSlider::dmSequentialGCodeView);
 
    wxBoxSizer* bottom_toolbar_sizer = new wxBoxSizer(wxHORIZONTAL);
    bottom_toolbar_sizer->Add(m_moves_slider, 1, wxALL | wxEXPAND, 0);
    m_bottom_toolbar_panel->SetSizer(bottom_toolbar_sizer);
 
    m_left_sizer->Add(m_bottom_toolbar_panel, 0, wxALL | wxEXPAND, 0);
    m_left_sizer->Hide(m_bottom_toolbar_panel);
 
    wxBoxSizer* main_sizer = new wxBoxSizer(wxHORIZONTAL);
    main_sizer->Add(m_left_sizer, 1, wxALL | wxEXPAND, 0);
    main_sizer->Add(right_sizer, 0, wxALL | wxEXPAND, 0);
 
    SetSizer(main_sizer);
    SetMinSize(GetSize());
    GetSizer()->SetSizeHints(this);
 
    bind_event_handlers();
    
    return true;
}

References Slic3r::GUI::GLCanvas3D::allow_multisample(), bind_event_handlers(), Slic3r::GUI::OpenGLManager::can_multisample(), create_layers_slider_sizer(), Slic3r::GUI::OpenGLManager::create_wxglcanvas(), Slic3r::DoubleSlider::dmSequentialGCodeView, Slic3r::GUI::GLCanvas3D::enable_dynamic_background(), Slic3r::GUI::GLCanvas3D::enable_legend_texture(), m_bottom_toolbar_panel, m_canvas, m_canvas_widget, m_config, m_layers_slider_sizer, m_left_sizer, m_moves_slider, m_process, Slic3r::GUI::GLCanvas3D::set_config(), Slic3r::GUI::GLCanvas3D::set_context(), Slic3r::GUI::GLCanvas3D::set_model(), Slic3r::GUI::GLCanvas3D::set_process(), and Slic3r::DoubleSlider::Control::SetDrawMode().

Referenced by Preview().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_loaded()

bool Slic3r::GUI::Preview::is_loaded ( ) const

inline

145{ return m_loaded; }

Slic3r::GUI::Preview::m_loaded

bool m_loaded

Definition GUI_Preview.hpp:100

References m_loaded.

Referenced by Slic3r::GUI::Plater::priv::is_preview_loaded().

Here is the caller graph for this function:

◆ jump_layers_slider()

void Slic3r::GUI::Preview::jump_layers_slider ( wxKeyEvent & evt )

{
    if (m_layers_slider) m_layers_slider->OnChar(evt);
}

References m_layers_slider, and Slic3r::DoubleSlider::Control::OnChar().

Here is the call graph for this function:

◆ load_print()

void Slic3r::GUI::Preview::load_print ( bool keep_z_range = false )

{
    PrinterTechnology tech = m_process->current_printer_technology();
    if (tech == ptFFF)
        load_print_as_fff(keep_z_range);
    else if (tech == ptSLA)
        load_print_as_sla();
 
    Layout();
}

References Slic3r::BackgroundSlicingProcess::current_printer_technology(), load_print_as_fff(), load_print_as_sla(), m_process, Slic3r::ptFFF, and Slic3r::ptSLA.

Referenced by Preview(), refresh_print(), and reload_print().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ load_print_as_fff()

void Slic3r::GUI::Preview::load_print_as_fff ( bool keep_z_range = false )

private

{
    if (wxGetApp().mainframe == nullptr || wxGetApp().is_recreating_gui())
        // avoid processing while mainframe is being constructed
        return;
 
    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 (wxGetApp().is_editor() && !has_layers) {
        hide_layers_slider();
        m_left_sizer->Hide(m_bottom_toolbar_panel);
        m_left_sizer->Layout();
        Refresh();
        m_canvas_widget->Refresh();
        return;
    }
 
    GCodeViewer::EViewType gcode_view_type = m_canvas->get_gcode_view_preview_type();
    bool gcode_preview_data_valid = !m_gcode_result->moves.empty();
 
    // Collect colors per extruder.
    std::vector<std::string> colors;
    std::vector<CustomGCode::Item> color_print_values = {};
    // set color print values, if it si selected "ColorPrint" view type
    if (gcode_view_type == GCodeViewer::EViewType::ColorPrint) {
        colors = wxGetApp().plater()->get_colors_for_color_print(m_gcode_result);
 
        if (!gcode_preview_data_valid) {
            if (wxGetApp().is_editor())
                color_print_values = wxGetApp().plater()->model().custom_gcode_per_print_z.gcodes;
            else
                color_print_values = m_canvas->get_custom_gcode_per_print_z();
            colors.push_back("#808080"); // gray color for pause print or custom G-code 
        }
    }
    else if (gcode_preview_data_valid || gcode_view_type == GCodeViewer::EViewType::Tool) {
        colors = wxGetApp().plater()->get_extruder_colors_from_plater_config(m_gcode_result);
        color_print_values.clear();
    }
 
    std::vector<double> zs;
 
    if (IsShown()) {
        m_canvas->set_selected_extruder(0);
        if (gcode_preview_data_valid) {
            // Load the real G-code preview.
            m_canvas->load_gcode_preview(*m_gcode_result, colors);
            m_left_sizer->Layout();
            Refresh();
            zs = m_canvas->get_gcode_layers_zs();
            if (!zs.empty())
                m_left_sizer->Show(m_bottom_toolbar_panel);
            m_loaded = true;
        }
        else if (wxGetApp().is_editor()) {
            // Load the initial preview based on slices, not the final G-code.
            m_canvas->load_preview(colors, color_print_values);
            m_left_sizer->Hide(m_bottom_toolbar_panel);
            m_left_sizer->Layout();
            Refresh();
            zs = m_canvas->get_volumes_print_zs(true);
        }
        else {
            m_left_sizer->Hide(m_bottom_toolbar_panel);
            m_left_sizer->Layout();
            Refresh();
        }
 
        if (!zs.empty() && !m_keep_current_preview_type) {
            unsigned int number_extruders = wxGetApp().is_editor() ?
                (unsigned int)print->extruders().size() :
                m_canvas->get_gcode_extruders_count();
            std::vector<Item> gcodes = wxGetApp().is_editor() ?
                wxGetApp().plater()->model().custom_gcode_per_print_z.gcodes :
                m_canvas->get_custom_gcode_per_print_z();
            const bool contains_color_gcodes = std::any_of(std::begin(gcodes), std::end(gcodes),
                [] (auto const& item) { return item.type == CustomGCode::Type::ColorChange; });
            const GCodeViewer::EViewType choice = contains_color_gcodes ?
                GCodeViewer::EViewType::ColorPrint :
                (number_extruders > 1) ? GCodeViewer::EViewType::Tool : GCodeViewer::EViewType::FeatureType;
            if (choice != gcode_view_type) {
                m_canvas->set_gcode_view_preview_type(choice);
                if (wxGetApp().is_gcode_viewer())
                    m_keep_current_preview_type = true;
                refresh_print();
            }
        }
 
        if (zs.empty()) {
            // all layers filtered out
            hide_layers_slider();
            m_canvas_widget->Refresh();
        } else
            update_layers_slider(zs, keep_z_range);
    }
}

Referenced by load_print().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ load_print_as_sla()

void Slic3r::GUI::Preview::load_print_as_sla ( )

private

{
    if (m_loaded || (m_process->current_printer_technology() != ptSLA))
        return;
 
    unsigned int n_layers = 0;
    const SLAPrint* print = m_process->sla_print();
 
    std::vector<double> zs;
    double initial_layer_height = print->material_config().initial_layer_height.value;
    for (const SLAPrintObject* obj : print->objects())
        if (obj->is_step_done(slaposSliceSupports) && !obj->get_slice_index().empty()) {
            auto low_coord = obj->get_slice_index().front().print_level();
            for (auto& rec : obj->get_slice_index())
                zs.emplace_back(initial_layer_height + (rec.print_level() - low_coord) * SCALING_FACTOR);
        }
    sort_remove_duplicates(zs);
 
    m_canvas->reset_clipping_planes_cache();
    m_canvas->set_use_clipping_planes(true);
 
    n_layers = (unsigned int)zs.size();
    if (n_layers == 0) {
        hide_layers_slider();
        m_canvas_widget->Refresh();
    }
 
    if (IsShown()) {
        m_canvas->load_sla_preview();
        m_left_sizer->Hide(m_bottom_toolbar_panel);
        m_left_sizer->Layout();
        Refresh();
 
        if (n_layers > 0)
            update_layers_slider(zs);
 
        m_loaded = true;
    }
}

References Slic3r::BackgroundSlicingProcess::current_printer_technology(), hide_layers_slider(), Slic3r::GUI::GLCanvas3D::load_sla_preview(), m_bottom_toolbar_panel, m_canvas, m_canvas_widget, m_left_sizer, m_loaded, m_process, Slic3r::SLAPrint::material_config(), Slic3r::SLAPrint::objects(), Slic3r::ptSLA, Slic3r::GUI::GLCanvas3D::reset_clipping_planes_cache(), SCALING_FACTOR, Slic3r::GUI::GLCanvas3D::set_use_clipping_planes(), Slic3r::BackgroundSlicingProcess::sla_print(), Slic3r::slaposSliceSupports, Slic3r::sort_remove_duplicates(), and update_layers_slider().

Referenced by load_print().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ move_layers_slider()

void Slic3r::GUI::Preview::move_layers_slider ( wxKeyEvent & evt )

{
    if (m_layers_slider != nullptr) m_layers_slider->OnKeyDown(evt);
}

References m_layers_slider, and Slic3r::DoubleSlider::Control::OnKeyDown().

Here is the call graph for this function:

◆ move_moves_slider()

void Slic3r::GUI::Preview::move_moves_slider ( wxKeyEvent & evt )

{
    if (m_moves_slider != nullptr) m_moves_slider->OnKeyDown(evt);
}

References m_moves_slider, and Slic3r::DoubleSlider::Control::OnKeyDown().

Here is the call graph for this function:

◆ msw_rescale()

void Slic3r::GUI::Preview::msw_rescale ( )

{
    // rescale slider
    if (m_layers_slider != nullptr) m_layers_slider->msw_rescale();
    if (m_moves_slider != nullptr) m_moves_slider->msw_rescale();
 
    // rescale warning legend on the canvas
    get_canvas3d()->msw_rescale();
 
    // rescale legend
    refresh_print();
}

References get_canvas3d(), m_layers_slider, m_moves_slider, Slic3r::DoubleSlider::Control::msw_rescale(), Slic3r::GUI::GLCanvas3D::msw_rescale(), and refresh_print().

Here is the call graph for this function:

◆ on_layers_slider_scroll_changed()

void Slic3r::GUI::Preview::on_layers_slider_scroll_changed ( wxCommandEvent & event )

private

{
    if (IsShown()) {
        PrinterTechnology tech = m_process->current_printer_technology();
        if (tech == ptFFF) {
            m_canvas->set_volumes_z_range({ m_layers_slider->GetLowerValueD(), m_layers_slider->GetHigherValueD() });
            m_canvas->set_toolpaths_z_range({ static_cast<unsigned int>(m_layers_slider->GetLowerValue()), static_cast<unsigned int>(m_layers_slider->GetHigherValue()) });
            m_canvas->set_as_dirty();
        }
        else if (tech == ptSLA) {
            m_canvas->set_clipping_plane(0, ClippingPlane(Vec3d::UnitZ(), -m_layers_slider->GetLowerValueD()));
            m_canvas->set_clipping_plane(1, ClippingPlane(-Vec3d::UnitZ(), m_layers_slider->GetHigherValueD()));
            m_canvas->render();
        }
    }
}

References Slic3r::BackgroundSlicingProcess::current_printer_technology(), Slic3r::DoubleSlider::Control::GetHigherValue(), Slic3r::DoubleSlider::Control::GetHigherValueD(), Slic3r::DoubleSlider::Control::GetLowerValue(), Slic3r::DoubleSlider::Control::GetLowerValueD(), m_canvas, m_layers_slider, m_process, Slic3r::ptFFF, Slic3r::ptSLA, Slic3r::GUI::GLCanvas3D::render(), Slic3r::GUI::GLCanvas3D::set_as_dirty(), Slic3r::GUI::GLCanvas3D::set_clipping_plane(), Slic3r::GUI::GLCanvas3D::set_toolpaths_z_range(), and Slic3r::GUI::GLCanvas3D::set_volumes_z_range().

Referenced by create_layers_slider_sizer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ on_moves_slider_scroll_changed()

void Slic3r::GUI::Preview::on_moves_slider_scroll_changed ( wxCommandEvent & event )

private

{
    m_canvas->update_gcode_sequential_view_current(static_cast<unsigned int>(m_moves_slider->GetLowerValueD() - 1.0), static_cast<unsigned int>(m_moves_slider->GetHigherValueD() - 1.0));
    m_canvas->render();
}

References Slic3r::DoubleSlider::Control::GetHigherValueD(), Slic3r::DoubleSlider::Control::GetLowerValueD(), m_canvas, m_moves_slider, Slic3r::GUI::GLCanvas3D::render(), and Slic3r::GUI::GLCanvas3D::update_gcode_sequential_view_current().

Referenced by bind_event_handlers(), and unbind_event_handlers().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ on_size()

void Slic3r::GUI::Preview::on_size ( wxSizeEvent & evt )

private

{
    evt.Skip();
    Refresh();
}

Referenced by bind_event_handlers(), and unbind_event_handlers().

Here is the caller graph for this function:

◆ refresh_print()

void Slic3r::GUI::Preview::refresh_print ( )

{
    m_loaded = false;
 
    if (!IsShown())
        return;
 
    load_print(true);
}

References load_print(), and m_loaded.

Referenced by load_print_as_fff(), and msw_rescale().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reload_print()

void Slic3r::GUI::Preview::reload_print ( bool keep_volumes = false )

{
#ifdef __linux__
    // We are getting mysterious crashes on Linux in gtk due to OpenGL context activation GH #1874 #1955.
    // So we are applying a workaround here: a delayed release of OpenGL vertex buffers.
    if (!IsShown())
    {
        m_volumes_cleanup_required = !keep_volumes;
        return;
    }
#endif /* __linux__ */
    if (
#ifdef __linux__
        m_volumes_cleanup_required || 
#endif /* __linux__ */
        !keep_volumes)
    {
        m_canvas->reset_volumes();
        m_loaded = false;
#ifdef __linux__
        m_volumes_cleanup_required = false;
#endif /* __linux__ */
    }
 
    load_print();
}

References load_print(), m_canvas, m_loaded, and Slic3r::GUI::GLCanvas3D::reset_volumes().

Referenced by create_layers_slider_sizer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reset_layers_slider()

void Slic3r::GUI::Preview::reset_layers_slider ( )

private

{
    m_layers_slider->SetHigherValue(0);
    m_layers_slider->SetLowerValue(0);
}

References m_layers_slider, Slic3r::DoubleSlider::Control::SetHigherValue(), and Slic3r::DoubleSlider::Control::SetLowerValue().

Here is the call graph for this function:

◆ select_view()

void Slic3r::GUI::Preview::select_view ( const std::string & direction )

{
    m_canvas->select_view(direction);
}

References m_canvas, and Slic3r::GUI::GLCanvas3D::select_view().

Here is the call graph for this function:

◆ set_as_dirty()

void Slic3r::GUI::Preview::set_as_dirty ( )

{
    if (m_canvas != nullptr)
        m_canvas->set_as_dirty();
}

References m_canvas, and Slic3r::GUI::GLCanvas3D::set_as_dirty().

Here is the call graph for this function:

◆ set_drop_target()

void Slic3r::GUI::Preview::set_drop_target ( wxDropTarget * target )

{
    if (target != nullptr)
        SetDropTarget(target);
}

◆ set_keep_current_preview_type()

void Slic3r::GUI::Preview::set_keep_current_preview_type ( bool value )

inline

152{ m_keep_current_preview_type = value; }

References m_keep_current_preview_type.

◆ set_layers_slider_values_range()

void Slic3r::GUI::Preview::set_layers_slider_values_range	(	int	bottom,
		int	top
	)

{
    m_layers_slider->SetHigherValue(std::min(top, m_layers_slider->GetMaxValue()));
    m_layers_slider->SetLowerValue(std::max(bottom, m_layers_slider->GetMinValue()));
}

References Slic3r::DoubleSlider::Control::GetMaxValue(), Slic3r::DoubleSlider::Control::GetMinValue(), m_layers_slider, Slic3r::DoubleSlider::Control::SetHigherValue(), and Slic3r::DoubleSlider::Control::SetLowerValue().

Here is the call graph for this function:

◆ sys_color_changed()

void Slic3r::GUI::Preview::sys_color_changed ( )

{
#ifdef _WIN32
    wxWindowUpdateLocker noUpdates(this);
    wxGetApp().UpdateAllStaticTextDarkUI(m_bottom_toolbar_panel);
#endif // _WIN32
 
    if (m_layers_slider != nullptr)
        m_layers_slider->sys_color_changed();
}

References m_bottom_toolbar_panel, m_layers_slider, and Slic3r::DoubleSlider::Control::sys_color_changed().

Here is the call graph for this function:

◆ unbind_event_handlers()

void Slic3r::GUI::Preview::unbind_event_handlers ( )

private

{
    Unbind(wxEVT_SIZE, &Preview::on_size, this);
    m_moves_slider->Unbind(wxEVT_SCROLL_CHANGED, &Preview::on_moves_slider_scroll_changed, this);
}

References m_moves_slider, on_moves_slider_scroll_changed(), and on_size().

Referenced by ~Preview().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_layers_slider()

void Slic3r::GUI::Preview::update_layers_slider	(	const std::vector< double > &	layers_z,
		bool	keep_z_range = `false`
	)

private

{
    // Save the initial slider span.
    double z_low = m_layers_slider->GetLowerValueD();
    double z_high = m_layers_slider->GetHigherValueD();
    bool   was_empty = m_layers_slider->GetMaxValue() == 0;
 
    bool force_sliders_full_range = was_empty;
    if (!keep_z_range)
    {
        bool span_changed = layers_z.empty() || std::abs(layers_z.back() - m_layers_slider->GetMaxValueD()) > DoubleSlider::epsilon()/*1e-6*/;
        force_sliders_full_range |= span_changed;
    }
    bool   snap_to_min = force_sliders_full_range || m_layers_slider->is_lower_at_min();
    bool   snap_to_max = force_sliders_full_range || m_layers_slider->is_higher_at_max();
 
    // Detect and set manipulation mode for double slider
    update_layers_slider_mode();
 
    Plater* plater = wxGetApp().plater();
    CustomGCode::Info ticks_info_from_model;
    if (wxGetApp().is_editor())
        ticks_info_from_model = plater->model().custom_gcode_per_print_z;
    else {
        ticks_info_from_model.mode = CustomGCode::Mode::SingleExtruder;
        ticks_info_from_model.gcodes = m_canvas->get_custom_gcode_per_print_z();
    }
    check_layers_slider_values(ticks_info_from_model.gcodes, layers_z);
 
    //first of all update extruder colors to avoid crash, when we are switching printer preset from MM to SM
    m_layers_slider->SetExtruderColors(plater->get_extruder_colors_from_plater_config(wxGetApp().is_editor() ? nullptr : m_gcode_result));
    m_layers_slider->SetSliderValues(layers_z);
    assert(m_layers_slider->GetMinValue() == 0);
    m_layers_slider->SetMaxValue(layers_z.empty() ? 0 : layers_z.size() - 1);
 
    int idx_low = 0;
    int idx_high = m_layers_slider->GetMaxValue();
    if (!layers_z.empty()) {
        if (!snap_to_min) {
            int idx_new = find_close_layer_idx(layers_z, z_low, DoubleSlider::epsilon()/*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, DoubleSlider::epsilon()/*1e-6*/);
            if (idx_new != -1)
                idx_high = idx_new;
        }
    }
    m_layers_slider->SetSelectionSpan(idx_low, idx_high);
    m_layers_slider->SetTicksValues(ticks_info_from_model);
 
    bool sla_print_technology = plater->printer_technology() == ptSLA;
    bool sequential_print = wxGetApp().preset_bundle->prints.get_edited_preset().config.opt_bool("complete_objects");
    m_layers_slider->SetDrawMode(sla_print_technology, sequential_print);
    if (sla_print_technology)
        m_layers_slider->SetLayersTimes(plater->sla_print().print_statistics().layers_times);
    else {
        auto print_mode_stat = m_gcode_result->print_statistics.modes.front();
        m_layers_slider->SetLayersTimes(print_mode_stat.layers_times, print_mode_stat.time);
    }
 
    // check if ticks_info_from_model contains ColorChange g-code
    bool color_change_already_exists = false;
    for (const CustomGCode::Item& gcode: ticks_info_from_model.gcodes)
        if (gcode.type == CustomGCode::Type::ColorChange) {
            color_change_already_exists = true;
            break;
        }
 
    // Suggest the auto color change, if model looks like sign
    if (!color_change_already_exists &&
        wxGetApp().app_config->get_bool("allow_auto_color_change") &&
        m_layers_slider->IsNewPrint())
    {
        const Print& print = wxGetApp().plater()->fff_print();
 
        //bool is_possible_auto_color_change = false;
        for (auto object : print.objects()) {
            double object_x = double(object->size().x());
            double object_y = double(object->size().y());
 
            // if it's sign, than object have not to be a too height
            double height = object->height();
            coord_t longer_side = std::max(object_x, object_y);
            auto   num_layers = int(object->layers().size());
            if (height / longer_side > 0.3 || num_layers < 2)
                continue;
 
            const ExPolygons& bottom = object->get_layer(0)->lslices;
            double bottom_area = area(bottom);
 
            // at least 25% of object's height have to be a solid 
            int  i, min_solid_height = int(0.25 * num_layers);
            for (i = 1; i <= min_solid_height; ++ i) {
                double cur_area = area(object->get_layer(i)->lslices);
                if (!DoubleSlider::equivalent_areas(bottom_area, cur_area)) {
                    // but due to the elephant foot compensation, the first layer may be slightly smaller than the others
                    if (i == 1 && fabs(cur_area - bottom_area) / bottom_area < 0.1) {
                        // So, let process this case and use second layer as a bottom 
                        bottom_area = cur_area;
                        continue;
                    }
                    break;
                }
            }
            if (i < min_solid_height)
                continue;
 
            if (DoubleSlider::check_color_change(object, i, num_layers, true, [this, object](const Layer*) {
                NotificationManager* notif_mngr = wxGetApp().plater()->get_notification_manager();
                notif_mngr->push_notification(
                    NotificationType::SignDetected, NotificationManager::NotificationLevel::PrintInfoNotificationLevel,
                    _u8L("NOTE:") + "\n" +
                    format(_u8L("Sliced object \"%1%\" looks like a logo or a sign"), object->model_object()->name) + "\n",
                    _u8L("Apply color change automatically"),
                    [this](wxEvtHandler*) {
                        m_layers_slider->auto_color_change();
                        return true;
                    });
 
                notif_mngr->apply_in_preview();
                return true;
            }) )
                // first object with color chnages is found
                break;
        }
    }
 
    m_layers_slider_sizer->Show((size_t)0);
    Layout();
}

Referenced by load_print_as_fff(), and load_print_as_sla().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_layers_slider_from_canvas()

void Slic3r::GUI::Preview::update_layers_slider_from_canvas ( wxKeyEvent & event )

private

{
    if (event.HasModifiers()) {
        event.Skip();
        return;
    }
 
    const auto key = event.GetKeyCode();
 
    if (key == 'S' || key == 'W') {
        const int new_pos = key == 'W' ? m_layers_slider->GetHigherValue() + 1 : m_layers_slider->GetHigherValue() - 1;
        m_layers_slider->SetHigherValue(new_pos);
        if (event.ShiftDown() || m_layers_slider->is_one_layer()) m_layers_slider->SetLowerValue(m_layers_slider->GetHigherValue());
    }
    else if (key == 'A' || key == 'D') {
        const int new_pos = key == 'D' ? m_moves_slider->GetHigherValue() + 1 : m_moves_slider->GetHigherValue() - 1;
        m_moves_slider->SetHigherValue(new_pos);
        if (event.ShiftDown() || m_moves_slider->is_one_layer()) m_moves_slider->SetLowerValue(m_moves_slider->GetHigherValue());
    }
    else if (key == 'X')
        m_layers_slider->ChangeOneLayerLock();
    else if (key == WXK_SHIFT)
        m_layers_slider->UseDefaultColors(false);
    else
        event.Skip();
}

References Slic3r::DoubleSlider::Control::ChangeOneLayerLock(), Slic3r::DoubleSlider::Control::GetHigherValue(), Slic3r::DoubleSlider::Control::is_one_layer(), m_layers_slider, m_moves_slider, Slic3r::DoubleSlider::Control::SetHigherValue(), Slic3r::DoubleSlider::Control::SetLowerValue(), and Slic3r::DoubleSlider::Control::UseDefaultColors().

Referenced by create_layers_slider_sizer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_layers_slider_mode()

void Slic3r::GUI::Preview::update_layers_slider_mode ( )

private

{
    //    true  -> single-extruder printer profile OR 
    //             multi-extruder printer profile , but whole model is printed by only one extruder
    //    false -> multi-extruder printer profile , and model is printed by several extruders
    bool    one_extruder_printed_model = true;
 
    // extruder used for whole model for multi-extruder printer profile
    int     only_extruder = -1; 
 
    if (wxGetApp().extruders_edited_cnt() > 1)
    {
        const ModelObjectPtrs& objects = wxGetApp().plater()->model().objects;
 
        // check if whole model uses just only one extruder
        if (!objects.empty())
        {
            const int extruder = objects[0]->config.has("extruder") ?
                                 objects[0]->config.option("extruder")->getInt() : 0;
 
            auto is_one_extruder_printed_model = [objects, extruder]()
            {
                for (ModelObject* object : objects)
                {
                    if (object->config.has("extruder") &&
                        object->config.option("extruder")->getInt() != extruder)
                        return false;
 
                    for (ModelVolume* volume : object->volumes)
                        if ((volume->config.has("extruder") && 
                            volume->config.option("extruder")->getInt() != 0 && // extruder isn't default
                            volume->config.option("extruder")->getInt() != extruder) ||
                            !volume->mmu_segmentation_facets.empty())
                            return false;
 
                    for (const auto& range : object->layer_config_ranges)
                        if (range.second.has("extruder") &&
                            range.second.option("extruder")->getInt() != 0 && // extruder isn't default
                            range.second.option("extruder")->getInt() != extruder)
                            return false;
                }
                return true;
            };
 
            if (is_one_extruder_printed_model())
                only_extruder = extruder;
            else
                one_extruder_printed_model = false;
        }
    }
 
    m_layers_slider->SetModeAndOnlyExtruder(one_extruder_printed_model, only_extruder);
}

References m_layers_slider, Slic3r::range(), and Slic3r::DoubleSlider::Control::SetModeAndOnlyExtruder().

Referenced by update_layers_slider().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_moves_slider()

void Slic3r::GUI::Preview::update_moves_slider ( )

{
    const GCodeViewer::SequentialView& view = m_canvas->get_gcode_sequential_view();
    // this should not be needed, but it is here to try to prevent rambling crashes on Mac Asan
    if (view.endpoints.last < view.endpoints.first)
        return;
 
    assert(view.endpoints.first <= view.current.first && view.current.first <= view.endpoints.last);
    assert(view.endpoints.first <= view.current.last && view.current.last <= view.endpoints.last);
 
    std::vector<double> values;
    values.reserve(view.endpoints.last - view.endpoints.first + 1);
    std::vector<double> alternate_values;
    alternate_values.reserve(view.endpoints.last - view.endpoints.first + 1);
    unsigned int last_gcode_id = view.gcode_ids[view.endpoints.first];
    for (unsigned int i = view.endpoints.first; i <= view.endpoints.last; ++i) {
        if (i > view.endpoints.first) {
            // skip consecutive moves with same gcode id (resulting from processing G2 and G3 lines)
            if (last_gcode_id == view.gcode_ids[i]) {
                values.back() = static_cast<double>(i + 1);
                alternate_values.back() = static_cast<double>(view.gcode_ids[i]);
                continue;
            }
            else
                last_gcode_id = view.gcode_ids[i];
        }
 
        values.emplace_back(static_cast<double>(i + 1));
        alternate_values.emplace_back(static_cast<double>(view.gcode_ids[i]));
    }
 
    m_moves_slider->SetSliderValues(values);
    m_moves_slider->SetSliderAlternateValues(alternate_values);
    m_moves_slider->SetMaxValue(int(values.size()) - 1);
    m_moves_slider->SetSelectionSpan(values.front() - 1 - view.endpoints.first, values.back() - 1 - view.endpoints.first);
}

References Slic3r::GUI::GCodeViewer::SequentialView::current, Slic3r::GUI::GCodeViewer::SequentialView::endpoints, Slic3r::GUI::GCodeViewer::SequentialView::Endpoints::first, Slic3r::GUI::GCodeViewer::SequentialView::gcode_ids, Slic3r::GUI::GLCanvas3D::get_gcode_sequential_view(), Slic3r::GUI::GCodeViewer::SequentialView::Endpoints::last, m_canvas, m_moves_slider, Slic3r::DoubleSlider::Control::SetMaxValue(), Slic3r::DoubleSlider::Control::SetSelectionSpan(), Slic3r::DoubleSlider::Control::SetSliderAlternateValues(), and Slic3r::DoubleSlider::Control::SetSliderValues().

Here is the call graph for this function:

Member Data Documentation

◆ m_bottom_toolbar_panel

wxPanel* Slic3r::GUI::Preview::m_bottom_toolbar_panel { nullptr }

private

Referenced by init(), load_print_as_fff(), load_print_as_sla(), and sys_color_changed().

◆ m_canvas

GLCanvas3D* Slic3r::GUI::Preview::m_canvas { nullptr }

private

Referenced by ~Preview(), bed_shape_changed(), get_canvas3d(), init(), load_print_as_fff(), load_print_as_sla(), on_layers_slider_scroll_changed(), on_moves_slider_scroll_changed(), reload_print(), select_view(), set_as_dirty(), update_layers_slider(), and update_moves_slider().

◆ m_canvas_widget

wxGLCanvas* Slic3r::GUI::Preview::m_canvas_widget { nullptr }

private

Referenced by ~Preview(), create_layers_slider_sizer(), get_wxglcanvas(), init(), load_print_as_fff(), and load_print_as_sla().

◆ m_config

DynamicPrintConfig* Slic3r::GUI::Preview::m_config

private

Referenced by init().

◆ m_gcode_result

GCodeProcessorResult* Slic3r::GUI::Preview::m_gcode_result

private

Referenced by load_print_as_fff(), and update_layers_slider().

◆ m_keep_current_preview_type

bool Slic3r::GUI::Preview::m_keep_current_preview_type { false }

private

Referenced by create_layers_slider_sizer(), load_print_as_fff(), and set_keep_current_preview_type().

◆ m_layers_slider

DoubleSlider::Control* Slic3r::GUI::Preview::m_layers_slider { nullptr }

private

Referenced by create_layers_slider_sizer(), edit_layers_slider(), jump_layers_slider(), move_layers_slider(), msw_rescale(), on_layers_slider_scroll_changed(), reset_layers_slider(), set_layers_slider_values_range(), sys_color_changed(), update_layers_slider(), update_layers_slider_from_canvas(), and update_layers_slider_mode().

◆ m_layers_slider_sizer

wxBoxSizer* Slic3r::GUI::Preview::m_layers_slider_sizer { nullptr }

private

Referenced by hide_layers_slider(), init(), and update_layers_slider().

◆ m_left_sizer

wxBoxSizer* Slic3r::GUI::Preview::m_left_sizer { nullptr }

private

Referenced by init(), load_print_as_fff(), and load_print_as_sla().

◆ m_loaded

bool Slic3r::GUI::Preview::m_loaded { false }

private

Referenced by is_loaded(), load_print_as_fff(), load_print_as_sla(), refresh_print(), and reload_print().

◆ m_moves_slider

DoubleSlider::Control* Slic3r::GUI::Preview::m_moves_slider { nullptr }

private

Referenced by bind_event_handlers(), enable_moves_slider(), init(), move_moves_slider(), msw_rescale(), on_moves_slider_scroll_changed(), unbind_event_handlers(), update_layers_slider_from_canvas(), and update_moves_slider().

◆ m_number_extruders

unsigned int Slic3r::GUI::Preview::m_number_extruders { 1 }

private

◆ m_process

BackgroundSlicingProcess* Slic3r::GUI::Preview::m_process

private

Referenced by init(), load_print(), load_print_as_fff(), load_print_as_sla(), and on_layers_slider_scroll_changed().

◆ m_schedule_background_process

std::function<void()> Slic3r::GUI::Preview::m_schedule_background_process

private

Referenced by check_layers_slider_values(), and create_layers_slider_sizer().

The documentation for this class was generated from the following files:

src/slic3r/GUI/GUI_Preview.hpp
src/slic3r/GUI/GUI_Preview.cpp

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ OptionType

Constructor & Destructor Documentation

◆ Preview()

◆ ~Preview()

Member Function Documentation

◆ bed_shape_changed()

◆ bind_event_handlers()

◆ check_layers_slider_values()

◆ create_layers_slider_sizer()

◆ edit_layers_slider()

◆ enable_moves_slider()

◆ get_canvas3d()

◆ get_wxglcanvas()

◆ hide_layers_slider()

◆ init()

◆ is_loaded()

◆ jump_layers_slider()

◆ load_print()

◆ load_print_as_fff()

◆ load_print_as_sla()

◆ move_layers_slider()

◆ move_moves_slider()

◆ msw_rescale()

◆ on_layers_slider_scroll_changed()

◆ on_moves_slider_scroll_changed()

◆ on_size()

◆ refresh_print()

◆ reload_print()

◆ reset_layers_slider()

◆ select_view()

◆ set_as_dirty()

◆ set_drop_target()

◆ set_keep_current_preview_type()

◆ set_layers_slider_values_range()

◆ sys_color_changed()

◆ unbind_event_handlers()

◆ update_layers_slider()

◆ update_layers_slider_from_canvas()

◆ update_layers_slider_mode()

◆ update_moves_slider()

Member Data Documentation

◆ m_bottom_toolbar_panel

◆ m_canvas

◆ m_canvas_widget

◆ m_config

◆ m_gcode_result

◆ m_keep_current_preview_type

◆ m_layers_slider

◆ m_layers_slider_sizer

◆ m_left_sizer

◆ m_loaded

◆ m_moves_slider

◆ m_number_extruders

◆ m_process

◆ m_schedule_background_process