Slic3r::GUI::Preview Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/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 , Shells , ToolMarker , Legend }

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 ()
void	update_gcode_result (GCodeProcessorResult *gcode_result)
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, bool only_gcode=false)
void	reload_print (bool only_gcode=false)
void	refresh_belt_view ()
void	load_shells (const Print &print, bool force_previewing=false)
void	reset_shells ()
void	msw_rescale ()
void	sys_color_changed ()
bool	is_loaded () const
void	on_tick_changed (CustomGCode::Type type)
void	show_sliders (bool show=true)
void	show_moves_sliders (bool show=true)
void	show_layers_sliders (bool show=true)
void	set_reload_paint_after_background_process_apply (bool flag)
bool	get_reload_paint_after_background_process_apply ()

Private Member Functions
bool	init (wxWindow *parent, Bed3D &bed, Model *model)
void	bind_event_handlers ()
void	unbind_event_handlers ()
void	on_size (wxSizeEvent &evt)
void	check_layers_slider_values (std::vector< CustomGCode::Item > &ticks_from_model, const std::vector< double > &layers_z)
void	update_layers_slider (const std::vector< double > &layers_z, bool keep_z_range=false)
void	update_layers_slider_mode ()
void	load_print_as_fff (bool keep_z_range=false, bool only_gcode=false)

Private Attributes
wxGLCanvas *	m_canvas_widget { nullptr }
GLCanvas3D *	m_canvas { 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 }
const Slic3r::PrintBase *	m_loaded_print { nullptr }
bool	m_only_gcode { false }
bool	m_reload_paint_after_background_process_apply {false}

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
Shells
ToolMarker
Legend

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

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(), load_print(), m_config, m_gcode_result, m_process, and m_schedule_background_process.

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 m_canvas.

bind_event_handlers()

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

private

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

References 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 - 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:

get_canvas3d()

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

inline

{ return m_canvas; }

References m_canvas.

Referenced by msw_rescale().

Here is the caller graph for this function:

get_reload_paint_after_background_process_apply()

bool Slic3r::GUI::Preview::get_reload_paint_after_background_process_apply ( )

inline

{ return m_reload_paint_after_background_process_apply; }

References m_reload_paint_after_background_process_apply.

get_wxglcanvas()

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

inline

{ return m_canvas_widget; }

References m_canvas_widget.

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);
#endif // ENABLE_OPENGL_AUTO_AA_SAMPLES
    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->set_type(GLCanvas3D::ECanvasType::CanvasPreview);
    m_canvas->get_gcode_viewer().enable_legend(true);
    //BBS: GUI refactor: GLToolbar
    if (wxGetApp().is_editor()) {
        m_canvas->enable_select_plate_toolbar(true);
    }
    m_canvas->enable_assemble_view_toolbar(false);
 
    // sizer, m_canvas_widget
    wxBoxSizer *main_sizer = new wxBoxSizer(wxVERTICAL);
    main_sizer->Add(m_canvas_widget, 1, wxALL | wxEXPAND, 0);
 
    SetSizer(main_sizer);
    SetMinSize(GetSize());
    GetSizer()->SetSizeHints(this);
 
    bind_event_handlers();
 
    return true;
}

References bind_event_handlers(), Slic3r::GUI::OpenGLManager::can_multisample(), Slic3r::GUI::GLCanvas3D::CanvasPreview, Slic3r::GUI::OpenGLManager::create_wxglcanvas(), m_canvas, m_canvas_widget, m_config, and m_process.

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

{ return (m_loaded_print != nullptr); }

References m_loaded_print.

load_print()

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

{
    PrinterTechnology tech = m_process->current_printer_technology();
    if (tech == ptFFF)
        load_print_as_fff(keep_z_range, only_gcode);
 
    Layout();
}

References load_print_as_fff(), m_process, and Slic3r::ptFFF.

Referenced by Preview(), refresh_belt_view(), 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, bool only_gcode = false )

private

{
    if (wxGetApp().mainframe == nullptr || wxGetApp().is_recreating_gui())
        // avoid processing while mainframe is being constructed
        return;
 
    //BBS: add m_loaded_print logic
    const Print *print = m_process->fff_print();
    BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(" %1%: previous print %2%, new print %3%")%__LINE__ %m_loaded_print %print;
    if ((m_loaded_print&&(m_loaded_print == print)) || m_process->current_printer_technology() != ptFFF) {
        BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(" %1%: already loaded before, return directly")%__LINE__;
        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;
    //BBS: always load shell at preview
    load_shells(*print, true);
    BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(" %1%: print: %2%, gcode_result %3%, check started")%__LINE__ %print %m_gcode_result;
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(" %1%: print is step done, posSlice %2%, posSupportMaterial %3%, psGCodeExport %4%") % __LINE__ % print->is_step_done(posSlice) %print->is_step_done(posSupportMaterial) % print->is_step_done(psGCodeExport);
    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;
            }
    }
 
    //BBS: support preview gcode directly even if no slicing
    bool directly_preview = print->is_step_done(psGCodeExport) && !m_gcode_result->moves.empty();
    BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": directly_preview: %1%, gcode_result moves %2%, has_layers %3%") % directly_preview % m_gcode_result->moves.size() %has_layers;
    if (wxGetApp().is_editor() && !has_layers && !directly_preview) {
        show_sliders(false);
        m_canvas_widget->Refresh();
        return;
    }
    //BBS: for direct preview, don't keep z range
    else if (directly_preview && !has_layers)
        keep_z_range = false;
 
    libvgcode::EViewType gcode_view_type = m_canvas->get_gcode_view_type();
    const bool gcode_preview_data_valid = !m_gcode_result->moves.empty();
    const bool is_pregcode_preview = !gcode_preview_data_valid && wxGetApp().is_editor();
 
    const std::vector<std::string> tool_colors = wxGetApp().plater()->get_extruder_colors_from_plater_config(m_gcode_result);
    const std::vector<CustomGCode::Item>& color_print_values = wxGetApp().is_editor() ?
        wxGetApp().plater()->model().get_curr_plate_custom_gcodes().gcodes : m_gcode_result->custom_gcode_per_print_z;
    std::vector<std::string> color_print_colors;
    if (!color_print_values.empty()) {
        color_print_colors = wxGetApp().plater()->get_colors_for_color_print(m_gcode_result);
        color_print_colors.push_back("#808080"); // gray color for pause print or custom G-code
    }
 
    std::vector<double> zs;
 
    if (IsShown()) {
        m_canvas->set_selected_extruder(0);
        bool is_slice_result_valid = wxGetApp().plater()->get_partplate_list().get_curr_plate()->is_slice_result_valid();
        if (gcode_preview_data_valid && (is_slice_result_valid || only_gcode)) {
            // Load the real G-code preview.
            //BBS: add more log
            BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": will load gcode_preview from result, moves count %1%") % m_gcode_result->moves.size();
            //BBS: add only gcode mode
            m_canvas->load_gcode_preview(*m_gcode_result, tool_colors, color_print_colors, only_gcode);
            // the view type may have been changed by the call m_canvas->load_gcode_preview()
            gcode_view_type = m_canvas->get_gcode_view_type();
            //BBS show sliders
            show_moves_sliders();
 
            //Orca: keep shell preview on but make it more transparent
            m_canvas->set_shells_on_previewing(true);
            m_canvas->set_shell_transparence();
            Refresh();
            zs = m_canvas->get_gcode_layers_zs();
            //BBS: add m_loaded_print logic
            //m_loaded = true;
            m_loaded_print = print;
        }
        else if (is_pregcode_preview) {
            // Load the initial preview based on slices, not the final G-code.
            //BBS: only display shell before slicing result out
            //m_canvas->load_preview(colors, color_print_values);
            show_moves_sliders(false);
            Refresh();
            //zs = m_canvas->get_volumes_print_zs(true);
        }
 
        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<CustomGCode::Item> gcodes = wxGetApp().is_editor() ?
                //BBS
                wxGetApp().plater()->model().get_curr_plate_custom_gcodes().gcodes :
                m_gcode_result->custom_gcode_per_print_z;
            const wxString choice = !gcodes.empty() ?
                _L("Multicolor Print") :
                (number_extruders > 1) ? _L("Filaments") : _L("Line Type");
        }
 
        if (zs.empty()) {
            // all layers filtered out
            //BBS
            show_layers_sliders(false);
            m_canvas_widget->Refresh();
        }
        else
            update_layers_slider(zs, keep_z_range);
    }
}

References _L, Slic3r::Print::extruders(), Slic3r::Print::is_step_done(), load_shells(), m_canvas, m_canvas_widget, m_gcode_result, m_keep_current_preview_type, m_loaded_print, m_process, Slic3r::Print::objects(), Slic3r::posSlice, Slic3r::posSupportMaterial, Slic3r::psGCodeExport, Slic3r::ptFFF, show_layers_sliders(), show_moves_sliders(), show_sliders(), and update_layers_slider().

Referenced by load_print().

Here is the call graph for this function:

Here is the caller graph for this function:

load_shells()

void Slic3r::GUI::Preview::load_shells	(	const Print &	print,
		bool	force_previewing = false )

{
    m_canvas->load_shells(print, force_previewing);
}

References m_canvas.

Referenced by load_print_as_fff(), and Slic3r::GUI::Plater::priv::update_fff_scene_only_shells().

Here is the caller graph for this function:

msw_rescale()

void Slic3r::GUI::Preview::msw_rescale

(

)

{
    // rescale warning legend on the canvas
    get_canvas3d()->msw_rescale();
 
    // rescale legend
    reload_print(m_only_gcode);
}

References get_canvas3d(), m_only_gcode, Slic3r::GUI::GLCanvas3D::msw_rescale(), and reload_print().

Here is the call 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:

on_tick_changed()

void Slic3r::GUI::Preview::on_tick_changed

(

CustomGCode::Type

type

)

{
    //if (type == Type::PausePrint) {
    //    m_schedule_background_process();
    //}
    m_keep_current_preview_type = false;
    reload_print(false);
}

References m_keep_current_preview_type, and reload_print().

Here is the call graph for this function:

refresh_belt_view()

void Slic3r::GUI::Preview::refresh_belt_view

(

)

{
    // Re-run the G-code preview conversion so the belt "designed view" toggle takes effect
    // (the back-transform is baked into the toolpath geometry in GCodeViewer::load_as_gcode,
    // whose same-result cache also keys on the view state, so the re-convert runs).
    // Reset m_loaded_print to bypass the "already loaded" guard the way reload_print does, but
    // keep the current layer range and only-gcode mode so the view doesn't jump on toggle.
    // The layer Z values differ between the designed and the raw view (the raw view's are
    // machine-frame heights), so keep_z_range alone cannot find the old span: carry the
    // slider over by layer index instead.
    IMSlider *layers_slider = m_canvas->get_gcode_viewer().get_layers_slider();
    const int lower  = layers_slider->GetLowerValue();
    const int higher = layers_slider->GetHigherValue();
    m_loaded_print = nullptr;
    load_print(true /*keep_z_range*/, m_only_gcode);
    if (higher <= layers_slider->GetMaxValue())
        layers_slider->SetSelectionSpan(lower, higher);
}

References Slic3r::GUI::IMSlider::GetHigherValue(), Slic3r::GUI::IMSlider::GetLowerValue(), load_print(), m_canvas, m_loaded_print, m_only_gcode, and Slic3r::GUI::IMSlider::SetSelectionSpan().

Here is the call graph for this function:

reload_print()

void Slic3r::GUI::Preview::reload_print

(

bool

only_gcode = false

)

{
    BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(" %1%: enter")%__LINE__;
 
    //BBS: add m_loaded_print logic
    //m_loaded = false;
    m_loaded_print = nullptr;
 
    load_print(false, only_gcode);
    m_only_gcode = only_gcode;
}

References load_print(), m_loaded_print, and m_only_gcode.

Referenced by msw_rescale(), Slic3r::GUI::Plater::priv::on_process_completed(), Slic3r::GUI::Plater::priv::on_slicing_update(), on_tick_changed(), Slic3r::GUI::Plater::priv::set_current_panel(), Slic3r::GUI::Plater::priv::update(), Slic3r::GUI::Plater::priv::update_fff_scene(), and Slic3r::GUI::Plater::priv::update_restart_background_process().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_shells()

void Slic3r::GUI::Preview::reset_shells

(

)

{
    m_canvas->reset_shells();
}

References m_canvas.

select_view()

void Slic3r::GUI::Preview::select_view

(

const std::string &

direction

)

{
    m_canvas->select_view(direction);
}

References m_canvas.

set_as_dirty()

void Slic3r::GUI::Preview::set_as_dirty

(

)

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

References m_canvas.

set_drop_target()

void Slic3r::GUI::Preview::set_drop_target

(

wxDropTarget *

target

)

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

set_reload_paint_after_background_process_apply()

void Slic3r::GUI::Preview::set_reload_paint_after_background_process_apply ( bool flag )

inline

{ m_reload_paint_after_background_process_apply = flag; }

References m_reload_paint_after_background_process_apply.

show_layers_sliders()

void Slic3r::GUI::Preview::show_layers_sliders

(

bool

show = true

)

{
    ;//TODO
}

Referenced by load_print_as_fff(), and show_sliders().

Here is the caller graph for this function:

show_moves_sliders()

void Slic3r::GUI::Preview::show_moves_sliders

(

bool

show = true

)

{
    ;//TODO
}

Referenced by load_print_as_fff(), and show_sliders().

Here is the caller graph for this function:

show_sliders()

void Slic3r::GUI::Preview::show_sliders

(

bool

show = true

)

{
    show_moves_sliders(show);
    show_layers_sliders(show);
}

References show_layers_sliders(), and show_moves_sliders().

Referenced by load_print_as_fff().

Here is the call graph for this function:

Here is the caller graph for this function:

sys_color_changed()

void Slic3r::GUI::Preview::sys_color_changed

(

)

{
    //TODO
    // m_layers_slider->sys_color_changed();
}

unbind_event_handlers()

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

private

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

References on_size().

Referenced by ~Preview().

Here is the call graph for this function:

Here is the caller graph for this function:

update_gcode_result()

void Slic3r::GUI::Preview::update_gcode_result

(

GCodeProcessorResult *

gcode_result

)

{
    m_gcode_result = gcode_result;
 
    return;
}

References m_gcode_result.

Referenced by Slic3r::GUI::Plater::priv::load_files(), Slic3r::GUI::Plater::priv::reload_from_disk(), Slic3r::GUI::Plater::priv::undo_redo_to(), and Slic3r::GUI::Plater::priv::update_background_process().

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

{
    IMSlider *m_layers_slider = m_canvas->get_gcode_viewer().get_layers_slider();
    // 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()) > 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();
    //BBS: replace model custom gcode with current plate custom gcode
    CustomGCode::Info ticks_info_from_curr_plate;
    if (wxGetApp().is_editor())
        ticks_info_from_curr_plate = plater->model().get_curr_plate_custom_gcodes();
    else {
        ticks_info_from_curr_plate.mode   = CustomGCode::Mode::SingleExtruder;
        ticks_info_from_curr_plate.gcodes = m_gcode_result->custom_gcode_per_print_z;
    }
    check_layers_slider_values(ticks_info_from_curr_plate.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, 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, epsilon() /*1e-6*/);
            if (idx_new != -1) idx_high = idx_new;
        }
    }
    m_layers_slider->SetSelectionSpan(idx_low, idx_high);
 
    auto curr_plate = wxGetApp().plater()->get_partplate_list().get_curr_plate();
    auto curr_print_seq = curr_plate->get_real_print_seq();
    bool sequential_print = (curr_print_seq == PrintSequence::ByObject);
    m_layers_slider->SetDrawMode(sequential_print);
    
    m_layers_slider->SetTicksValues(ticks_info_from_curr_plate);
 
    auto print_mode_stat = m_gcode_result->print_statistics.modes.front();
    m_layers_slider->SetLayersTimes(m_canvas->get_gcode_layers_times_cache(), print_mode_stat.time);
 
    // Suggest the auto color change, if model looks like sign
    if (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 (!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;
        }
    }
}

References Slic3r::area(), Slic3r::ByObject, check_layers_slider_values(), Slic3r::GUI::epsilon(), Slic3r::GUI::equivalent_areas(), Slic3r::GUI::find_close_layer_idx(), Slic3r::CustomGCode::Info::gcodes, Slic3r::GUI::IMSlider::GetHigherValueD(), Slic3r::GUI::IMSlider::GetLowerValueD(), Slic3r::GUI::IMSlider::GetMaxValue(), Slic3r::GUI::IMSlider::GetMaxValueD(), Slic3r::GUI::IMSlider::GetMinValue(), Slic3r::GUI::IMSlider::is_higher_at_max(), Slic3r::GUI::IMSlider::is_lower_at_min(), Slic3r::GUI::IMSlider::IsNewPrint(), m_canvas, m_gcode_result, Slic3r::CustomGCode::Info::mode, Slic3r::Print::objects(), Slic3r::GUI::plater(), Slic3r::GUI::IMSlider::SetDrawMode(), Slic3r::GUI::IMSlider::SetExtruderColors(), Slic3r::GUI::IMSlider::SetLayersTimes(), Slic3r::GUI::IMSlider::SetMaxValue(), Slic3r::GUI::IMSlider::SetSelectionSpan(), Slic3r::GUI::IMSlider::SetSliderValues(), Slic3r::GUI::IMSlider::SetTicksValues(), Slic3r::CustomGCode::SingleExtruder, and update_layers_slider_mode().

Referenced by load_print_as_fff().

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;
    bool can_change_color = true;
    // extruder used for whole model for multi-extruder printer profile
    int only_extruder = -1;
 
    // BBS
    if (wxGetApp().filaments_cnt() > 1) {
        //const ModelObjectPtrs& objects = wxGetApp().plater()->model().objects;
        auto plate_extruders = wxGetApp().plater()->get_partplate_list().get_curr_plate()->get_extruders_without_support();
        for (auto extruder : plate_extruders) {
            if (extruder != plate_extruders[0])
                can_change_color = false;
        }
        // check if whole model uses just only one extruder
        if (!plate_extruders.empty()) {
            //const int extruder = objects[0]->config.has("extruder") ? objects[0]->config.option("extruder")->getInt() : 0;
            only_extruder = plate_extruders[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() != 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() != extruder) return false;
            //        }
            //        return true;
            //    };
 
            //    if (is_one_extruder_printed_model())
            //        only_extruder = extruder;
            //    else
            //        one_extruder_printed_model = false;
        }
    }
 
    IMSlider *m_layers_slider = m_canvas->get_gcode_viewer().get_layers_slider();
    m_layers_slider->SetModeAndOnlyExtruder(one_extruder_printed_model, only_extruder, can_change_color);
}

References m_canvas, and Slic3r::GUI::IMSlider::SetModeAndOnlyExtruder().

Referenced by update_layers_slider().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_canvas

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

private

{ nullptr };

Referenced by ~Preview(), bed_shape_changed(), get_canvas3d(), init(), load_print_as_fff(), load_shells(), refresh_belt_view(), reset_shells(), select_view(), set_as_dirty(), update_layers_slider(), and update_layers_slider_mode().

m_canvas_widget

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

private

{ nullptr };

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

m_config

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

private

Referenced by Preview(), and init().

m_gcode_result

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

private

Referenced by Preview(), load_print_as_fff(), update_gcode_result(), and update_layers_slider().

m_keep_current_preview_type

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

private

{ false };

Referenced by load_print_as_fff(), and on_tick_changed().

m_loaded_print

const Slic3r::PrintBase* Slic3r::GUI::Preview::m_loaded_print { nullptr }

private

{ nullptr };

Referenced by is_loaded(), load_print_as_fff(), refresh_belt_view(), and reload_print().

m_number_extruders

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

private

{ 1 };

m_only_gcode

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

private

{ false };

Referenced by msw_rescale(), refresh_belt_view(), and reload_print().

m_process

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

private

Referenced by Preview(), init(), load_print(), and load_print_as_fff().

m_reload_paint_after_background_process_apply

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

private

{false};

Referenced by get_reload_paint_after_background_process_apply(), and set_reload_paint_after_background_process_apply().

m_schedule_background_process

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

private

Referenced by Preview(), and check_layers_slider_values().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/GUI_Preview.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/GUI_Preview.cpp