Slic3r::GUI::ObjectList Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/GUI_ObjectList.hpp>

Inheritance diagram for Slic3r::GUI::ObjectList:

Collaboration diagram for Slic3r::GUI::ObjectList:

Classes
struct	Clipboard
struct	dragged_item_data

Public Types
enum	SELECTION_MODE {   smUndef = 0 , smVolume = 1 , smInstance = 2 , smLayer = 4 ,   smSettings = 8 , smLayerRoot = 16 }
enum	OBJECT_ORGANIZE_TYPE { ortByPlate = 0 , ortByModule = 1 }

Public Member Functions
	ObjectList (wxWindow *parent)
	~ObjectList () override
void	set_min_height ()
void	update_min_height ()
ObjectDataViewModel *	GetModel () const
ModelConfig *	config () const
std::vector< ModelObject * > *	objects () const
ModelObject *	object (const int obj_idx) const
void	create_objects_ctrl ()
void	update_objects_list_filament_column (size_t filaments_count)
void	update_objects_list_filament_column_when_delete_filament (size_t filament_id, size_t filaments_count, int replace_filament_id=-1)
void	update_filament_colors ()
void	set_filament_column_hidden (const bool hide) const
void	set_variable_height_column_hidden (const bool hide) const
void	set_color_paint_hidden (const bool hide) const
void	set_support_paint_hidden (const bool hide) const
void	set_sinking_hidden (const bool hide) const
void	update_filament_in_config (const wxDataViewItem &item)
void	update_name_in_model (const wxDataViewItem &item) const
void	update_name_in_list (int obj_idx, int vol_idx) const
void	update_filament_values_for_items (const size_t filaments_count)
void	update_filament_values_for_items_when_delete_filament (const size_t filament_id, const int replace_id=-1)
void	update_plate_values_for_items ()
void	update_name_for_items ()
void	get_selected_item_indexes (int &obj_idx, int &vol_idx, const wxDataViewItem &item=wxDataViewItem(0))
void	get_selection_indexes (std::vector< int > &obj_idxs, std::vector< int > &vol_idxs)
int	get_repaired_errors_count (const int obj_idx, const int vol_idx=-1) const
MeshErrorsInfo	get_mesh_errors_info (const int obj_idx, const int vol_idx=-1, wxString *sidebar_info=nullptr, int *non_manifold_edges=nullptr) const
MeshErrorsInfo	get_mesh_errors_info (wxString *sidebar_info=nullptr, int *non_manifold_edges=nullptr)
void	set_tooltip_for_item (const wxPoint &pt)
void	selection_changed ()
void	show_context_menu (const bool evt_context_menu)
void	extruder_editing ()
void	key_event (wxKeyEvent &event)
bool	dispatch_shortcut (Shortcut shortcut)
void	copy ()
void	paste ()
void	cut ()
void	clone ()
bool	cut_to_clipboard ()
bool	copy_to_clipboard ()
bool	paste_from_clipboard ()
void	undo ()
void	redo ()
void	increase_instances ()
void	decrease_instances ()
void	add_category_to_settings_from_selection (const std::vector< std::pair< std::string, bool > > &category_options, wxDataViewItem item)
void	add_category_to_settings_from_frequent (const std::vector< std::string > &category_options, wxDataViewItem item)
void	show_settings (const wxDataViewItem settings_item)
bool	is_instance_or_object_selected ()
void	load_subobject (ModelVolumeType type, bool from_galery=false)
void	load_modifier (const wxArrayString &input_files, ModelObject &model_object, std::vector< ModelVolume * > &added_volumes, ModelVolumeType type, bool from_galery=false)
void	load_generic_subobject (const std::string &type_name, const ModelVolumeType type)
void	load_shape_object (const std::string &type_name)
void	load_mesh_object (const TriangleMesh &mesh, const wxString &name, bool center=true)
void	load_mesh_object (const std::vector< std::pair< const TriangleMesh *, wxString > > &parts, const wxString &name, bool center=true)
void	switch_to_object_process ()
bool	del_object (const int obj_idx, bool refresh_immediately=true)
void	del_subobject_item (wxDataViewItem &item)
void	del_settings_from_config (const wxDataViewItem &parent_item)
void	del_instances_from_object (const int obj_idx)
void	del_layer_from_object (const int obj_idx, const t_layer_height_range &layer_range)
void	del_layers_from_object (const int obj_idx)
bool	del_from_cut_object (bool is_connector, bool is_model_part=false, bool is_negative_volume=false)
bool	del_subobject_from_object (const int obj_idx, const int idx, const int type)
void	del_info_item (const int obj_idx, InfoItemType type)
void	split ()
void	merge (bool to_multipart_object)
void	layers_editing ()
void	boolean ()
wxDataViewItem	add_layer_root_item (const wxDataViewItem obj_item)
wxDataViewItem	add_settings_item (wxDataViewItem parent_item, const DynamicPrintConfig *config)
DynamicPrintConfig	get_default_layer_config (const int obj_idx)
bool	get_volume_by_item (const wxDataViewItem &item, ModelVolume *&volume)
bool	is_splittable (bool to_objects)
bool	selected_instances_of_same_object ()
bool	can_split_instances ()
bool	can_merge_to_multipart_object () const
bool	can_merge_to_single_object () const
bool	can_mesh_boolean () const
bool	has_selected_cut_object () const
void	invalidate_cut_info_for_selection ()
void	invalidate_cut_info_for_object (int obj_idx)
void	delete_all_connectors_for_selection ()
void	delete_all_connectors_for_object (int obj_idx)
wxPoint	get_mouse_position_in_control () const
int	get_selected_obj_idx () const
ModelConfig &	get_item_config (const wxDataViewItem &item) const
void	changed_object (const int obj_idx=-1) const
void	part_selection_changed ()
void	add_objects_to_list (std::vector< size_t > obj_idxs, bool call_selection_changed=true, bool notify_partplate=true, bool do_info_update=true)
void	add_object_to_list (size_t obj_idx, bool call_selection_changed=true, bool notify_partplate=true, bool do_info_update=true)
wxDataViewItemArray	add_volumes_to_object_in_list (size_t obj_idx, std::function< bool(const ModelVolume *)> add_to_selection=nullptr)
void	delete_object_from_list ()
void	delete_object_from_list (const size_t obj_idx)
void	delete_volume_from_list (const size_t obj_idx, const size_t vol_idx)
void	delete_instance_from_list (const size_t obj_idx, const size_t inst_idx)
void	delete_from_model_and_list (const ItemType type, const int obj_idx, const int sub_obj_idx)
void	delete_from_model_and_list (const std::vector< ItemForDelete > &items_for_delete)
void	update_lock_icons_for_model ()
void	delete_all_objects_from_list ()
void	increase_object_instances (const size_t obj_idx, const size_t num)
void	decrease_object_instances (const size_t obj_idx, const size_t num)
void	unselect_objects ()
void	select_object_item (bool is_msr_gizmo)
void	remove ()
void	del_layer_range (const t_layer_height_range &range)
void	add_layer_range_after_current (const t_layer_height_range current_range)
wxString	can_add_new_range_after_current (t_layer_height_range current_range)
void	add_layer_item (const t_layer_height_range &range, const wxDataViewItem layers_item, const int layer_idx=-1)
bool	edit_layer_range (const t_layer_height_range &range, coordf_t layer_height)
bool	edit_layer_range (const t_layer_height_range &range, const t_layer_height_range &new_range, bool suppress_ui_update=false)
void	init ()
bool	multiple_selection () const
bool	is_selected (const ItemType type) const
bool	is_connectors_item_selected () const
bool	is_connectors_item_selected (const wxDataViewItemArray &sels) const
int	get_selected_layers_range_idx () const
void	set_selected_layers_range_idx (const int range_idx)
void	set_selection_mode (SELECTION_MODE mode)
void	update_selections ()
void	update_selections_on_canvas ()
void	select_item (const wxDataViewItem &item)
void	select_item (std::function< wxDataViewItem()> get_item)
void	select_items (const wxDataViewItemArray &sels)
void	select_item (const ObjectVolumeID &ov_id)
void	select_items (const std::vector< ObjectVolumeID > &ov_ids)
void	select_all ()
void	select_item_all_children ()
void	update_selection_mode ()
bool	check_last_selection (wxString &msg_str)
void	fix_multiselection_conflicts ()
void	fix_cut_selection ()
bool	fix_cut_selection (wxDataViewItemArray &sels)
ModelVolume *	get_selected_model_volume ()
void	set_volume_type (ModelVolumeType new_type, bool preserve_ps_subtype=true)
ModelVolumeType	get_selected_volume_type ()
void	last_volume_is_deleted (const int obj_idx)
void	update_and_show_object_settings_item ()
void	update_settings_item_and_selection (wxDataViewItem item, wxDataViewItemArray &selections)
void	update_object_list_by_printer_technology ()
void	update_info_items (size_t obj_idx, wxDataViewItemArray *selections=nullptr, bool added_object=false, bool color_mode_changed=false)
void	update_variable_layer_obj_num (ObjectDataViewModelNode *obj_node, size_t layer_data_count)
void	instances_to_separated_object (const int obj_idx, const std::set< int > &inst_idx)
void	instances_to_separated_objects (const int obj_idx)
void	split_instances ()
void	rename_item ()
void	fix_through_cgal ()
void	fix_all_through_cgal (bool all_plates)
void	fix_through_cgal (const std::vector< int > &obj_idxs, const std::vector< int > &vol_idxs)
void	simplify ()
void	smooth_mesh ()
void	update_item_error_icon (const int obj_idx, int vol_idx) const
void	copy_layers_to_clipboard ()
void	paste_layers_into_list ()
void	copy_settings_to_clipboard ()
void	paste_settings_into_list ()
bool	can_paste_settings_into_list ()
bool	clipboard_is_empty () const
void	paste_volumes_into_list (int obj_idx, const ModelVolumePtrs &volumes)
void	paste_objects_into_list (const std::vector< size_t > &object_idxs)
void	msw_rescale ()
void	sys_color_changed ()
void	update_after_undo_redo ()
void	update_printable_state (int obj_idx, int instance_idx)
void	toggle_printable_state ()
void	toggle_auto_drop ()
void	enable_layers_editing ()
void	set_extruder_for_selected_items (const int extruder)
wxDataViewItemArray	reorder_volumes_and_get_selection (int obj_idx, std::function< bool(const ModelVolume *)> add_to_selection=nullptr)
void	apply_volumes_order ()
void	on_plate_added (PartPlate *part_plate)
void	on_plate_deleted (int plate_index)
void	reload_all_plates (bool notify_partplate=false)
void	on_plate_selected (int plate_index)
void	notify_instance_updated (int obj_idx)
void	object_config_options_changed (const ObjectVolumeID &ov_id)
void	printable_state_changed (const std::vector< ModelObject * > model_objects)
void	printable_state_changed (const std::vector< ObjectVolumeID > &ov_ids)
void	assembly_plate_object_name ()
void	selected_object (ObjectDataViewModelNode *item)

Private Member Functions
void	ensure_current_item_visible ()
void	OnContextMenu (wxDataViewEvent &event)
void	list_manipulation (const wxPoint &mouse_pos, bool evt_context_menu=false)
void	update_name_column_width () const
void	OnBeginDrag (wxDataViewEvent &event)
void	OnDropPossible (wxDataViewEvent &event)
void	OnDrop (wxDataViewEvent &event)
bool	can_drop (const wxDataViewItem &item, int &src_obj_id, int &src_plate, int &dest_obj_id, int &dest_plate) const
void	ItemValueChanged (wxDataViewEvent &event)
void	OnStartEditing (wxDataViewEvent &event)
void	OnEditingStarted (wxDataViewEvent &event)
void	OnEditingDone (wxDataViewEvent &event)
void	apply_object_instance_transfrom_to_all_volumes (ModelObject *model_object, bool need_update_assemble_matrix=true)

Private Attributes
SELECTION_MODE	m_selection_mode {smUndef}
int	m_selected_layers_range_idx {-1}
Clipboard	m_clipboard
struct Slic3r::GUI::ObjectList::dragged_item_data	m_dragged_data
ObjectDataViewModel *	m_objects_model { nullptr }
ModelConfig *	m_config {nullptr}
std::vector< ModelObject * > *	m_objects { nullptr }
size_t	m_variable_layer_obj_num = 0
BitmapComboBox *	m_extruder_editor { nullptr }
std::vector< wxBitmap * >	m_bmp_vector
int	m_selected_object_id = -1
bool	m_prevent_list_events = false
bool	m_prevent_list_manipulation = false
bool	m_prevent_update_filament_in_config = false
bool	m_prevent_canvas_selection_update = false
wxDataViewItem	m_last_selected_item {nullptr}
size_t	m_items_count { size_t(-1) }
std::vector< int >	m_columns_width
wxSize	m_last_size

Detailed Description

Member Enumeration Documentation

OBJECT_ORGANIZE_TYPE

enum Slic3r::GUI::ObjectList::OBJECT_ORGANIZE_TYPE

Enumerator
ortByPlate
ortByModule

    {
        ortByPlate = 0,
        ortByModule = 1,
    };

SELECTION_MODE

enum Slic3r::GUI::ObjectList::SELECTION_MODE

Enumerator
smUndef
smVolume
smInstance
smLayer
smSettings
smLayerRoot

    {
        smUndef     = 0,
        smVolume    = 1,
        smInstance  = 2,
        smLayer     = 4,
        smSettings  = 8,  // used for undo/redo
        smLayerRoot = 16, // used for undo/redo
    };

Constructor & Destructor Documentation

ObjectList()

Slic3r::GUI::ObjectList::ObjectList

(

wxWindow *

parent

)

                                       :
    wxDataViewCtrl(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxDV_MULTIPLE | wxNO_BORDER | wxDV_NO_HEADER) // ORCA: Remove border and header
{
    wxGetApp().UpdateDVCDarkUI(this, true);
 
#ifdef __linux__
    // Temporary fix for incorrect dark mode application regarding list item's text color.
    // See: https://github.com/OrcaSlicer/OrcaSlicer/issues/2086
    this->SetForegroundColour(*wxBLACK);
#endif
 
    SetFont(Label::sysFont(13));
#ifdef __WXMSW__
    static auto render = new wxRenderer;
    wxRendererNative::Set(render);
#endif
 
    // create control
    create_objects_ctrl();
 
    //BBS: add part plate related event
    //Bind(EVT_PARTPLATE_LIST_PLATE_SELECT, &ObjectList::on_select_plate, this);
 
    // describe control behavior
    Bind(wxEVT_DATAVIEW_SELECTION_CHANGED, [this](wxDataViewEvent& event) {
        // detect the current mouse position here, to pass it to list_manipulation() method
        // if we detect it later, the user may have moved the mouse pointer while calculations are performed, and this would mess-up the HitTest() call performed into list_manipulation()
        if (!GetScreenRect().Contains(wxGetMousePosition())) {
            return;
        }
#ifndef __WXOSX__
        const wxPoint mouse_pos = this->get_mouse_position_in_control();
#endif
 
#ifndef __APPLE__
        // On Windows and Linux:
        // It's not invoked KillFocus event for "temporary" panels (like "Manipulation panel", "Settings", "Layer ranges"),
        // if we change selection in object list.
        // But, if we call SetFocus() for ObjectList it will cause an invoking of a KillFocus event for "temporary" panels
        this->SetFocus();
#else
        // To avoid selection update from SetSelection() and UnselectAll() under osx
        if (m_prevent_list_events)
            return;
#endif // __APPLE__
 
        /* For multiple selection with pressed SHIFT,
         * event.GetItem() returns value of a first item in selection list
         * instead of real last clicked item.
         * So, let check last selected item in such strange way
         */
#ifdef __WXMSW__
    // Workaround for entering the column editing mode on Windows. Simulate keyboard enter when another column of the active line is selected.
    int new_selected_column = -1;
#endif //__WXMSW__
        if (wxGetKeyState(WXK_SHIFT))
        {
            wxDataViewItemArray sels;
            GetSelections(sels);
            if (! sels.empty() && sels.front() == m_last_selected_item)
                m_last_selected_item = sels.back();
            else
                m_last_selected_item = event.GetItem();
        }
        else {
            wxDataViewItem    new_selected_item  = event.GetItem();
            // BBS: use wxDataViewCtrl's internal mechanism
#if 0
#ifdef __WXMSW__
      // Workaround for entering the column editing mode on Windows. Simulate keyboard enter when another column of the active line is selected.
        wxDataViewItem    item;
        wxDataViewColumn *col;
        this->HitTest(this->get_mouse_position_in_control(), item, col);
        new_selected_column = (col == nullptr) ? -1 : (int)col->GetModelColumn();
          if (new_selected_item == m_last_selected_item && m_last_selected_column != -1 && m_last_selected_column != new_selected_column) {
            // Mouse clicked on another column of the active row. Simulate keyboard enter to enter the editing mode of the current column.
            wxUIActionSimulator sim;
        sim.Char(WXK_RETURN);
          }
#endif //__WXMSW__
#endif
          m_last_selected_item = new_selected_item;
        }
#ifdef __WXMSW__
        m_last_selected_column = new_selected_column;
#endif //__WXMSW__
 
        ObjectDataViewModelNode* sel_node = (ObjectDataViewModelNode*)event.GetItem().GetID();
        if (sel_node && (sel_node->GetType() & ItemType::itPlate)) {
            if (wxGetApp().plater()->is_preview_shown()) {
                wxGetApp().plater()->select_sliced_plate(sel_node->GetPlateIdx());
            } else {
                wxGetApp().plater()->select_plate(sel_node->GetPlateIdx());
            }
            wxGetApp().plater()->deselect_all();
        }
        else {
            selection_changed();
        }
#ifndef __WXMSW__
        set_tooltip_for_item(this->get_mouse_position_in_control());
#endif //__WXMSW__
 
#ifndef __WXOSX__
        list_manipulation(mouse_pos);
#endif //__WXOSX__
    });
 
#ifdef __WXOSX__
    // Key events are not correctly processed by the wxDataViewCtrl on OSX.
    // Our patched wxWidgets process the keyboard accelerators.
    // On the other hand, using accelerators will break in-place editing on Windows & Linux/GTK (there is no in-place editing working on OSX for wxDataViewCtrl for now).
    m_shortcut_id_base = wxWindow::NewControlId(int(Shortcut::Count));
    for (size_t i = 0; i < size_t(Shortcut::Count); ++i)
        this->Bind(wxEVT_MENU, [this, shortcut = Shortcut(i)](wxCommandEvent&) { dispatch_shortcut(shortcut); }, m_shortcut_id_base + int(i));
    for (int i = 1; i < 10; i++)
        this->Bind(wxEVT_MENU, [this, i](wxCommandEvent &evt) {
            if (filaments_count() > 1 && i <= filaments_count())
                this->set_extruder_for_selected_items(i);
        }, wxID_LAST+i);
    update_shortcut_accelerators();
#else //__WXOSX__
    Bind(wxEVT_CHAR, [this](wxKeyEvent& event) { key_event(event); }); // doesn't work on OSX
#endif
 
#ifdef __WXMSW__
    GetMainWindow()->Bind(wxEVT_MOTION, [this](wxMouseEvent& event) {
        // BBS
        // this->SetFocus();
        set_tooltip_for_item(this->get_mouse_position_in_control());
        event.Skip();
    });
#endif //__WXMSW__
 
    Bind(wxEVT_DATAVIEW_ITEM_CONTEXT_MENU,  &ObjectList::OnContextMenu,     this);
 
    // BBS
    Bind(wxEVT_DATAVIEW_ITEM_BEGIN_DRAG,    &ObjectList::OnBeginDrag,       this);
    Bind(wxEVT_DATAVIEW_ITEM_DROP_POSSIBLE, &ObjectList::OnDropPossible,    this);
    Bind(wxEVT_DATAVIEW_ITEM_DROP,          &ObjectList::OnDrop,            this);
 
    Bind(wxEVT_DATAVIEW_ITEM_START_EDITING, &ObjectList::OnStartEditing, this);
    Bind(wxEVT_DATAVIEW_ITEM_EDITING_STARTED, &ObjectList::OnEditingStarted,  this);
    Bind(wxEVT_DATAVIEW_ITEM_EDITING_DONE,    &ObjectList::OnEditingDone,     this);
 
    Bind(wxEVT_DATAVIEW_ITEM_VALUE_CHANGED, &ObjectList::ItemValueChanged,  this);
 
    // BBS: dont need to do extra setting for a deleted object
    //Bind(wxCUSTOMEVT_LAST_VOLUME_IS_DELETED, [this](wxCommandEvent& e)   { last_volume_is_deleted(e.GetInt()); });
 
    Bind(wxEVT_SIZE, ([this](wxSizeEvent &e) {
             if (m_last_size == this->GetSize()) {
                 e.Skip();
                 return;
             } else {
                 m_last_size = this->GetSize();
             }
 
        update_name_column_width();
 
        // BBS
        this->CallAfter([this]() { ensure_current_item_visible(); });
 
        e.Skip();
    }));
    m_last_size = this->GetSize();
}

References Slic3r::GUI::Count, create_objects_ctrl(), dispatch_shortcut(), ensure_current_item_visible(), Slic3r::GUI::filaments_count(), get_mouse_position_in_control(), Slic3r::GUI::ObjectDataViewModelNode::GetPlateIdx(), Slic3r::GUI::ObjectDataViewModelNode::GetType(), ItemValueChanged(), Slic3r::GUI::itPlate, key_event(), list_manipulation(), m_last_selected_item, m_last_size, m_prevent_list_events, OnBeginDrag(), OnContextMenu(), OnDrop(), OnDropPossible(), OnEditingDone(), OnEditingStarted(), OnStartEditing(), Slic3r::GUI::plater(), selection_changed(), set_extruder_for_selected_items(), set_tooltip_for_item(), Label::sysFont(), update_name_column_width(), and Slic3r::GUI::wxMouseEvent.

Referenced by update_name_column_width().

Here is the call graph for this function:

Here is the caller graph for this function:

~ObjectList()

Slic3r::GUI::ObjectList::~ObjectList ( )

override

{
    if (m_objects_model)
            m_objects_model->DecRef();
}

References m_objects_model.

Member Function Documentation

add_category_to_settings_from_frequent()

void Slic3r::GUI::ObjectList::add_category_to_settings_from_frequent	(	const std::vector< std::string > &	category_options,
		wxDataViewItem	item )

{
    const ItemType item_type = m_objects_model->GetItemType(item);
 
    if (!m_config)
        m_config = &get_item_config(item);
 
    assert(m_config);
    auto opt_keys = m_config->keys();
 
    const std::string snapshot_text = item_type & itLayer  ? _u8L("Height range settings added") :
                                   item_type & itVolume ? _u8L("Part settings added") :
                                                          _u8L("Object settings added");
    take_snapshot(snapshot_text);
 
    const DynamicPrintConfig& from_config = wxGetApp().preset_bundle->prints.get_edited_preset().config;
    for (auto& opt_key : options)
    {
        if (find(opt_keys.begin(), opt_keys.end(), opt_key) == opt_keys.end()) {
            const ConfigOption* option = from_config.option(opt_key);
            if (!option) {
                // if current option doesn't exist in prints.get_edited_preset(),
                // get it from default config values
                option = DynamicPrintConfig::new_from_defaults_keys({ opt_key })->option(opt_key);
            }
            m_config->set_key_value(opt_key, option->clone());
        }
    }
 
    // Add settings item for object/sub-object and show them
    if (!(item_type & (itPlate | itObject | itVolume | itLayer)))
        item = m_objects_model->GetObject(item);
 
    show_settings(add_settings_item(item, &m_config->get()));
}

References _u8L, add_settings_item(), Slic3r::ConfigOption::clone(), get_item_config(), Slic3r::GUI::itLayer, Slic3r::GUI::itObject, Slic3r::GUI::itPlate, Slic3r::GUI::itVolume, m_config, m_objects_model, Slic3r::DynamicPrintConfig::new_from_defaults_keys(), Slic3r::ConfigBase::option(), show_settings(), and Slic3r::GUI::take_snapshot().

Referenced by Slic3r::GUI::create_freq_settings_popupmenu().

Here is the call graph for this function:

Here is the caller graph for this function:

add_category_to_settings_from_selection()

void Slic3r::GUI::ObjectList::add_category_to_settings_from_selection	(	const std::vector< std::pair< std::string, bool > > &	category_options,
		wxDataViewItem	item )

{
    if (category_options.empty())
        return;
 
    const ItemType item_type = m_objects_model->GetItemType(item);
 
    if (!m_config)
        m_config = &get_item_config(item);
 
    assert(m_config);
    auto opt_keys = m_config->keys();
 
    const std::string snapshot_text =  item_type & itLayer   ? _u8L("Layer setting added") :
                                    item_type & itVolume  ? _u8L("Part setting added") :
                                                            _u8L("Object setting added");
    take_snapshot(snapshot_text);
 
    const DynamicPrintConfig& from_config = printer_technology() == ptFFF ?
                                            wxGetApp().preset_bundle->prints.get_edited_preset().config :
                                            wxGetApp().preset_bundle->sla_prints.get_edited_preset().config;
 
    for (auto& opt : category_options) {
        auto& opt_key = opt.first;
        if (find(opt_keys.begin(), opt_keys.end(), opt_key) != opt_keys.end() && !opt.second)
            m_config->erase(opt_key);
 
        if (find(opt_keys.begin(), opt_keys.end(), opt_key) == opt_keys.end() && opt.second) {
            const ConfigOption* option = from_config.option(opt_key);
            if (!option) {
                // if current option doesn't exist in prints.get_edited_preset(),
                // get it from default config values
                option = DynamicPrintConfig::new_from_defaults_keys({ opt_key })->option(opt_key);
            }
            m_config->set_key_value(opt_key, option->clone());
        }
    }
 
    // Add settings item for object/sub-object and show them
    if (!(item_type & (itPlate | itObject | itVolume | itLayer)))
        item = m_objects_model->GetObject(item);
    show_settings(add_settings_item(item, &m_config->get()));
}

References _u8L, add_settings_item(), Slic3r::ConfigOption::clone(), get_item_config(), Slic3r::GUI::itLayer, Slic3r::GUI::itObject, Slic3r::GUI::itPlate, Slic3r::GUI::itVolume, m_config, m_objects_model, Slic3r::DynamicPrintConfig::new_from_defaults_keys(), Slic3r::ConfigBase::option(), Slic3r::GUI::printer_technology(), Slic3r::ptFFF, show_settings(), and Slic3r::GUI::take_snapshot().

Here is the call graph for this function:

add_layer_item()

void Slic3r::GUI::ObjectList::add_layer_item	(	const t_layer_height_range &	range,
		const wxDataViewItem	layers_item,
		const int	layer_idx = -1 )

{
    const int obj_idx = m_objects_model->GetObjectIdByItem(layers_item);
    if (obj_idx < 0) return;
 
    const DynamicPrintConfig& config = object(obj_idx)->layer_config_ranges[range].get();
    if (!config.has("extruder"))
        return;
 
    const auto layer_item = m_objects_model->AddLayersChild(layers_item,
                                                            range,
                                                            config.opt_int("extruder"),
                                                            layer_idx);
    add_settings_item(layer_item, &config);
}

References add_settings_item(), config(), Slic3r::ModelObject::layer_config_ranges, m_objects_model, object(), and Slic3r::range().

Referenced by add_layer_range_after_current(), add_layer_root_item(), and edit_layer_range().

Here is the call graph for this function:

Here is the caller graph for this function:

add_layer_range_after_current()

void Slic3r::GUI::ObjectList::add_layer_range_after_current

(

const t_layer_height_range

current_range

)

{
    const int obj_idx = get_selected_obj_idx();
    assert(obj_idx >= 0);
    if (obj_idx < 0)
        // This should not happen.
        return;
 
    const wxDataViewItem layers_item = GetSelection();
 
    auto& ranges = object(obj_idx)->layer_config_ranges;
    auto it_range = ranges.find(current_range);
    assert(it_range != ranges.end());
    if (it_range == ranges.end())
        // This shoudl not happen.
        return;
 
    auto it_next_range = it_range;
    bool changed = false;
    if (++ it_next_range == ranges.end())
    {
        // Adding a new layer height range after the last one.
        // BBS: remove snapshot name "Add Height Range"
        take_snapshot("");
        changed = true;
 
        const t_layer_height_range new_range = { current_range.second, current_range.second + 2. };
        ranges[new_range].assign_config(get_default_layer_config(obj_idx));
        add_layer_item(new_range, layers_item);
    }
    else if (const std::pair<coordf_t, coordf_t> &next_range = it_next_range->first; current_range.second <= next_range.first)
    {
        const int layer_idx = m_objects_model->GetItemIdByLayerRange(obj_idx, next_range);
        assert(layer_idx >= 0);
        if (layer_idx >= 0)
        {
            if (current_range.second == next_range.first)
            {
                // Splitting the next layer height range to two.
                const auto old_config = ranges.at(next_range);
                const coordf_t delta = next_range.second - next_range.first;
                // Layer height of the current layer.
                const coordf_t old_min_layer_height = get_min_layer_height(old_config.opt_int("extruder"));
                // Layer height of the layer to be inserted.
                const coordf_t new_min_layer_height = get_min_layer_height(0);
                if (delta >= old_min_layer_height + new_min_layer_height - EPSILON) {
                    const coordf_t middle_layer_z = (new_min_layer_height > 0.5 * delta) ?
                      next_range.second - new_min_layer_height :
                      next_range.first + std::max(old_min_layer_height, 0.5 * delta);
                    t_layer_height_range new_range = { middle_layer_z, next_range.second };
 
                    // BBS: remove snapshot name "Add Height Range"
                    Plater::TakeSnapshot snapshot(wxGetApp().plater(), "");
                    changed = true;
 
                    // create new 2 layers instead of deleted one
                    // delete old layer
 
                    wxDataViewItem layer_item = m_objects_model->GetItemByLayerRange(obj_idx, next_range);
                    del_subobject_item(layer_item);
 
                    ranges[new_range] = old_config;
                    add_layer_item(new_range, layers_item, layer_idx);
 
                    new_range = { current_range.second, middle_layer_z };
                    ranges[new_range].assign_config(get_default_layer_config(obj_idx));
                    add_layer_item(new_range, layers_item, layer_idx);
                }
            }
            else if (next_range.first - current_range.second >= get_min_layer_height(0) - EPSILON)
            {
                // Filling in a gap between the current and a new layer height range with a new one.
                // BBS: remove snapshot name "Add Height Range"
                take_snapshot("");
                changed = true;
 
                const t_layer_height_range new_range = { current_range.second, next_range.first };
                ranges[new_range].assign_config(get_default_layer_config(obj_idx));
                add_layer_item(new_range, layers_item, layer_idx);
            }
        }
    }
 
    if (changed)
        changed_object(obj_idx);
 
    // The layer range panel is updated even if this function does not change the layer ranges, as the panel update
    // may have been postponed from the "kill focus" event of a text field, if the focus was lost for the "add layer" button.
    // select item to update layers sizer
    select_item(layers_item);
}

References add_layer_item(), changed_object(), del_subobject_item(), EPSILON, get_default_layer_config(), Slic3r::GUI::get_min_layer_height(), get_selected_obj_idx(), Slic3r::ModelObject::layer_config_ranges, m_objects_model, object(), Slic3r::GUI::plater(), select_item(), and Slic3r::GUI::take_snapshot().

Here is the call graph for this function:

add_layer_root_item()

wxDataViewItem Slic3r::GUI::ObjectList::add_layer_root_item

(

const wxDataViewItem

obj_item

)

{
    const int obj_idx = m_objects_model->GetIdByItem(obj_item);
    if (obj_idx < 0 ||
        object(obj_idx)->layer_config_ranges.empty() ||
        printer_technology() == ptSLA)
        return wxDataViewItem(nullptr);
 
    // create LayerRoot item
    wxDataViewItem layers_item = m_objects_model->AddLayersRoot(obj_item);
 
    // and create Layer item(s) according to the layer_config_ranges
    for (const auto& range : object(obj_idx)->layer_config_ranges)
        add_layer_item(range.first, layers_item);
 
    Expand(layers_item);
    return layers_item;
}

References add_layer_item(), m_objects_model, Slic3r::GUI::printer_technology(), Slic3r::ptSLA, and Slic3r::range().

Referenced by add_object_to_list(), layers_editing(), paste_layers_into_list(), and update_object_list_by_printer_technology().

Here is the call graph for this function:

Here is the caller graph for this function:

add_object_to_list()

void Slic3r::GUI::ObjectList::add_object_to_list	(	size_t	obj_idx,
		bool	call_selection_changed = true,
		bool	notify_partplate = true,
		bool	do_info_update = true )

{
    auto model_object = (*m_objects)[obj_idx];
    //BBS start add obj_idx for debug
    PartPlateList& list = wxGetApp().plater()->get_partplate_list();
    if (notify_partplate) {
        list.notify_instance_update(obj_idx, 0, true);
    }
    //int plate_idx = list.find_instance_belongs(obj_idx, 0);
    //std::string item_name_str = (boost::format("[P%1%][O%2%]%3%") % plate_idx % std::to_string(obj_idx) % model_object->name).str();
    //std::string item_name_str = (boost::format("[P%1%]%2%") % plate_idx  % model_object->name).str();
    //const wxString& item_name = from_u8(item_name_str);
    const wxString& item_name = from_u8(model_object->name);
    std::string warning_bitmap = get_warning_icon_name(model_object->mesh().stats());
    const auto item = m_objects_model->AddObject(model_object, warning_bitmap, model_object->is_cut());
    Expand(m_objects_model->GetParent(item));
 
    {
        Slic3r::LifecycleEventContext ctx;
        ctx.name = model_object->name;
        ctx.code = Slic3r::LifecycleEvtCode::Ok;
        Slic3r::fire_lifecycle_event(Slic3r::LifecycleEvent::ObjectAdded, ctx);
    }
 
    if (!do_info_update)
        return;
 
    update_info_items(obj_idx, nullptr, call_selection_changed);
 
    add_volumes_to_object_in_list(obj_idx);
 
    // add instances to the object, if it has those
    if (model_object->instances.size()>1)
    {
        std::vector<bool> print_idicator(model_object->instances.size());
        std::vector<int> plate_idicator(model_object->instances.size());
        for (size_t i = 0; i < model_object->instances.size(); ++i) {
            print_idicator[i] = model_object->instances[i]->printable;
            plate_idicator[i] = list.find_instance_belongs(obj_idx, i);
        }
 
        const wxDataViewItem object_item = m_objects_model->GetItemById(obj_idx);
        m_objects_model->AddInstanceChild(object_item, print_idicator, plate_idicator);
        Expand(m_objects_model->GetInstanceRootItem(object_item));
    }
    else
        m_objects_model->SetPrintableState(model_object->instances[0]->printable ? piPrintable : piUnprintable, obj_idx);
 
    m_objects_model->SetObjectVariableHeightState(model_object->layer_height_profile.get().size() > 4 ? hiVariable : hiUnVariable, m_objects_model->GetItemById(obj_idx));
 
    // add settings to the object, if it has those
    add_settings_item(item, &model_object->config.get());
 
    // Add layers if it has
    add_layer_root_item(item);
 
#ifndef __WXOSX__
    if (call_selection_changed) {
        UnselectAll();
        Select(item);
        selection_changed();
    }
#endif //__WXMSW__
}

References add_layer_root_item(), add_settings_item(), add_volumes_to_object_in_list(), Slic3r::LifecycleEventContext::code, Slic3r::GUI::PartPlateList::find_instance_belongs(), Slic3r::fire_lifecycle_event(), Slic3r::GUI::from_u8(), Slic3r::GUI::get_warning_icon_name(), Slic3r::GUI::hiUnVariable, Slic3r::GUI::hiVariable, m_objects_model, Slic3r::LifecycleEventContext::name, Slic3r::GUI::PartPlateList::notify_instance_update(), Slic3r::ObjectAdded, Slic3r::Ok, Slic3r::GUI::piPrintable, Slic3r::GUI::piUnprintable, selection_changed(), and update_info_items().

Referenced by Slic3r::GUI::Plater::_calib_pa_pattern(), add_objects_to_list(), boolean(), instances_to_separated_object(), instances_to_separated_objects(), merge(), paste_objects_into_list(), and reload_all_plates().

Here is the call graph for this function:

Here is the caller graph for this function:

add_objects_to_list()

void Slic3r::GUI::ObjectList::add_objects_to_list	(	std::vector< size_t >	obj_idxs,
		bool	call_selection_changed = true,
		bool	notify_partplate = true,
		bool	do_info_update = true )

{
#ifdef __WXOSX__
    AssociateModel(nullptr);
#endif
    for (const size_t idx : obj_idxs) {
        add_object_to_list(idx, call_selection_changed, notify_partplate, do_info_update);
    }
#ifdef __WXOSX__
    AssociateModel(m_objects_model);
#endif
}

References add_object_to_list(), and m_objects_model.

Here is the call graph for this function:

add_settings_item()

wxDataViewItem Slic3r::GUI::ObjectList::add_settings_item	(	wxDataViewItem	parent_item,
		const DynamicPrintConfig *	config )

{
    wxDataViewItem ret = wxDataViewItem(nullptr);
 
    if (!parent_item)
        return ret;
 
    const bool is_object_settings = m_objects_model->GetItemType(parent_item) == itObject;
    const bool is_volume_settings = m_objects_model->GetItemType(parent_item) == itVolume;
    const bool is_layer_settings = m_objects_model->GetItemType(parent_item) == itLayer;
    if (!is_object_settings) {
        ModelVolumeType volume_type = m_objects_model->GetVolumeType(parent_item);
        // Precise Seam is non-printing helper geometry — no per-volume settings
        if (volume_type == ModelVolumeType::NEGATIVE_VOLUME || volume_type == ModelVolumeType::SUPPORT_BLOCKER || volume_type == ModelVolumeType::SUPPORT_ENFORCER || is_precise_seam(volume_type))
            return ret;
    }
 
    SettingsFactory::Bundle cat_options = SettingsFactory::get_bundle(config, is_object_settings, is_layer_settings);
    if (is_layer_settings) {
        auto tab_object = dynamic_cast<TabPrintModel*>(wxGetApp().get_model_tab());
        auto object_cfg = tab_object->get_config();
        if (config->opt_float("layer_height") == object_cfg->opt_float("layer_height")) {
            SettingsFactory::Bundle new_cat_options;
            for (auto cat_opt : cat_options) {
                std::vector<std::string> temp;
                for (auto value : cat_opt.second) {
                    if (value != "layer_height")
                        temp.push_back(value);
                }
                if (!temp.empty())
                    new_cat_options[cat_opt.first] = temp;
            }
            cat_options = new_cat_options;
        }
    }
 
    if (cat_options.empty()) {
#if NEW_OBJECT_SETTING
        ObjectDataViewModelNode *node = static_cast<ObjectDataViewModelNode*>(parent_item.GetID());
        if (node) node->set_action_icon(false);
        m_objects_model->ItemChanged(parent_item);
        return parent_item;
#else
        return ret;
#endif
    }
 
    std::vector<std::string> categories;
    categories.reserve(cat_options.size());
    for (auto& cat : cat_options)
        categories.push_back(cat.first);
 
    if (m_objects_model->GetItemType(parent_item) & itInstance)
        parent_item = m_objects_model->GetObject(parent_item);
 
#if NEW_OBJECT_SETTING
    ObjectDataViewModelNode *node = static_cast<ObjectDataViewModelNode*>(parent_item.GetID());
    if (node) node->set_action_icon(true);
    m_objects_model->ItemChanged(parent_item);
    return parent_item;
#else
    ret = m_objects_model->IsSettingsItem(parent_item) ? parent_item : m_objects_model->GetSettingsItem(parent_item);
 
    if (!ret) ret = m_objects_model->AddSettingsChild(parent_item);
 
    m_objects_model->UpdateSettingsDigest(ret, categories);
    Expand(parent_item);
 
    return ret;
#endif
}

References config(), Slic3r::GUI::SettingsFactory::get_bundle(), Slic3r::GUI::Tab::get_config(), Slic3r::is_precise_seam(), Slic3r::GUI::itInstance, Slic3r::GUI::itLayer, Slic3r::GUI::itObject, Slic3r::GUI::itVolume, m_objects_model, Slic3r::NEGATIVE_VOLUME, Slic3r::GUI::ObjectDataViewModelNode::set_action_icon(), Slic3r::SUPPORT_BLOCKER, and Slic3r::SUPPORT_ENFORCER.

Referenced by add_category_to_settings_from_frequent(), add_category_to_settings_from_selection(), add_layer_item(), add_object_to_list(), add_volumes_to_object_in_list(), del_subobject_from_object(), object_config_options_changed(), paste_settings_into_list(), split(), and update_settings_item_and_selection().

Here is the call graph for this function:

Here is the caller graph for this function:

add_volumes_to_object_in_list()

wxDataViewItemArray Slic3r::GUI::ObjectList::add_volumes_to_object_in_list	(	size_t	obj_idx,
		std::function< bool(const ModelVolume *)>	add_to_selection = nullptr )

{
    const bool is_prevent_list_events = m_prevent_list_events;
    m_prevent_list_events             = true;
 
    wxDataViewItem object_item = m_objects_model->GetItemById(int(obj_idx));
    m_objects_model->DeleteVolumeChildren(object_item);
 
    wxDataViewItemArray items;
 
    const ModelObject *object = (*m_objects)[obj_idx];
    // add volumes to the object
    if (can_add_volumes_to_object(object)) {
        if (object->volumes.size() > 1) {
            wxString obj_item_name = from_u8(object->name);
            if (m_objects_model->GetName(object_item) != obj_item_name)
                m_objects_model->SetName(obj_item_name, object_item);
        }
 
        int volume_idx{-1};
        auto& ui_and_3d_volume_map = m_objects_model->get_ui_and_3d_volume_map();
        for (auto item : ui_and_3d_volume_map) {
            if (item.first == obj_idx) {
                item.second.clear();
            }
        }
        int ui_volume_idx = 0;
        for (const ModelVolume *volume : object->volumes) {
            ++volume_idx;
            if (object->is_cut() && volume->is_cut_connector())
                continue;
 
            const wxDataViewItem &vol_item = m_objects_model->AddVolumeChild(
                object_item,
                from_u8(volume->name),
                volume->type(),
                volume->is_text(),
                volume->is_svg(),
                get_warning_icon_name(volume->mesh().stats()),
                volume->config.has("extruder") ? volume->config.extruder() : 0,
                false);
            ui_and_3d_volume_map[obj_idx][ui_volume_idx] = volume_idx;
            ui_volume_idx++;
            add_settings_item(vol_item, &volume->config.get());
 
            if (add_to_selection && add_to_selection(volume))
                items.Add(vol_item);
        }
        Expand(object_item);
    }
 
    m_prevent_list_events = is_prevent_list_events;
    return items;
}

References add_settings_item(), Slic3r::GUI::can_add_volumes_to_object(), Slic3r::ModelVolume::config, Slic3r::ModelConfig::extruder(), Slic3r::GUI::from_u8(), Slic3r::ModelConfig::get(), Slic3r::GUI::get_warning_icon_name(), Slic3r::ModelConfig::has(), Slic3r::ModelVolume::is_cut_connector(), Slic3r::ModelVolume::is_svg(), Slic3r::ModelVolume::is_text(), m_objects_model, m_prevent_list_events, Slic3r::ModelVolume::mesh(), Slic3r::ModelVolume::name, object(), Slic3r::TriangleMesh::stats(), and Slic3r::ModelVolume::type().

Referenced by add_object_to_list(), delete_all_connectors_for_object(), invalidate_cut_info_for_object(), and reorder_volumes_and_get_selection().

Here is the call graph for this function:

Here is the caller graph for this function:

apply_object_instance_transfrom_to_all_volumes()

void Slic3r::GUI::ObjectList::apply_object_instance_transfrom_to_all_volumes ( ModelObject * model_object, bool need_update_assemble_matrix = true )

private

{
    const Geometry::Transformation &instance_transformation  = model_object->instances[0]->get_transformation();
    Vec3d                           original_instance_center = instance_transformation.get_offset();
 
    if (need_update_assemble_matrix) {
        // apply the instance_transform(except offset) to assemble_transform
        Geometry::Transformation instance_transformation_copy = instance_transformation;
        instance_transformation_copy.set_offset(Vec3d(0, 0, 0)); // remove the effect of offset
        const Transform3d &instance_inverse_matrix = instance_transformation_copy.get_matrix().inverse();
        const Transform3d &assemble_matrix         = model_object->instances[0]->get_assemble_transformation().get_matrix();
        Transform3d        new_assemble_transform  = assemble_matrix * instance_inverse_matrix;
        model_object->instances[0]->set_assemble_from_transform(new_assemble_transform);
    }
 
    // apply the instance_transform to volumn
    const Transform3d &transformation_matrix = instance_transformation.get_matrix();
    for (ModelVolume *volume : model_object->volumes) {
        const Transform3d &volume_matrix = volume->get_matrix();
        Transform3d        new_matrix    = transformation_matrix * volume_matrix;
        volume->set_transformation(new_matrix);
    }
    model_object->instances[0]->set_transformation(Geometry::Transformation());
 
    model_object->ensure_on_bed();
    // keep new instance center the same as the original center
    model_object->translate(-original_instance_center);
    model_object->translate_instances(original_instance_center);
 
    // update the cache data in selection to keep the data of ModelVolume and GLVolume are consistent
    wxGetApp().plater()->update();
}

References Slic3r::ModelObject::ensure_on_bed(), Slic3r::Geometry::Transformation::get_matrix(), Slic3r::ModelVolume::get_matrix(), Slic3r::Geometry::Transformation::get_offset(), Slic3r::ModelObject::instances, Slic3r::Geometry::Transformation::set_offset(), Slic3r::ModelVolume::set_transformation(), Slic3r::ModelObject::translate(), Slic3r::ModelObject::translate_instances(), and Slic3r::ModelObject::volumes.

Referenced by load_generic_subobject().

Here is the call graph for this function:

Here is the caller graph for this function:

apply_volumes_order()

void Slic3r::GUI::ObjectList::apply_volumes_order

(

)

{
    if (!m_objects)
        return;
 
    for (size_t obj_idx = 0; obj_idx < m_objects->size(); obj_idx++)
        reorder_volumes_and_get_selection(obj_idx);
}

References m_objects, and reorder_volumes_and_get_selection().

Here is the call graph for this function:

assembly_plate_object_name()

void Slic3r::GUI::ObjectList::assembly_plate_object_name

(

)

{
    m_objects_model->assembly_name();
}

References m_objects_model.

boolean()

void Slic3r::GUI::ObjectList::boolean

(

)

{
    std::vector<int> obj_idxs, vol_idxs;
    get_selection_indexes(obj_idxs, vol_idxs);
    if (obj_idxs.empty() && vol_idxs.empty())
        return;
 
    Plater::TakeSnapshot snapshot(wxGetApp().plater(), "boolean");
 
    ModelObject* object = (*m_objects)[obj_idxs.front()];
 
    const bool keep_painting = wxGetApp().app_config->get_bool("keep_painting");
    std::vector<std::optional<TriangleSelector::SavedPainting>> saved_paintings;
    if (keep_painting) {
        // Save painting of all the positive parts
        saved_paintings.reserve(object->volumes.size());
        for (const ModelVolume* vol : object->volumes) {
            if (vol && vol->mesh_ptr() && vol->is_model_part() && vol->is_any_painted()) {
                saved_paintings.emplace_back(vol->save_painting());
                if (saved_paintings.back()) {
                    saved_paintings.back()->mesh.transform(vol->get_matrix(), true);
                }
            }
        }
    }
 
    TriangleMesh mesh = Plater::combine_mesh_fff(*object, -1, [](const std::string& msg) {return wxGetApp().notification_manager()->push_plater_error_notification(msg); });
 
    // add mesh to model as a new object, keep the original object's name and config
    Model* model = object->get_model();
    ModelObject* new_object = model->add_object();
    new_object->name = object->name;
    new_object->config.assign_config(object->config);
    if (new_object->instances.empty())
        new_object->add_instance();
    ModelVolume* new_volume = new_object->add_volume(mesh);
 
    // Remap paint
    if (keep_painting) {
        for (auto& saved_painting : saved_paintings) {
            if (saved_painting) {
                // For each original painted volume, we need to apply to each instance
                // because we merged all instances into one in `combine_mesh_fff`
 
                // First we save the non-instance-translated mesh
                TriangleMesh vols_mesh(std::move(saved_painting->mesh));
                
                for (const ModelInstance* i : object->instances) {
                    // Then for each instance, we apply the paint at the given instance place
                    saved_painting->mesh = vols_mesh;
                    saved_painting->mesh.transform(i->get_matrix());
 
                    // Then paint it
                    new_volume->restore_painting(saved_painting, true);
                }
 
            }
        }
    }
 
    // BBS: ensure on bed but no need to ensure locate in the center around origin
    new_object->ensure_on_bed();
    new_object->center_around_origin();
    new_object->translate_instances(-new_object->origin_translation);
    new_object->origin_translation = Vec3d::Zero();
 
    // BBS: notify it before move
    notify_instance_updated(m_objects->size() - 1);
 
    // remove selected objects
    remove();
 
    // Add new object(UNION) to the object_list
    add_object_to_list(m_objects->size() - 1);
    select_item(m_objects_model->GetItemById(m_objects->size() - 1));
    update_selections_on_canvas();
}

References Slic3r::ModelObject::add_instance(), add_object_to_list(), Slic3r::ModelObject::add_volume(), Slic3r::ModelConfig::assign_config(), Slic3r::ModelObject::center_around_origin(), Slic3r::GUI::Plater::combine_mesh_fff(), Slic3r::ModelObject::config, Slic3r::ModelObject::ensure_on_bed(), Slic3r::ModelInstance::get_matrix(), Slic3r::ModelVolume::get_matrix(), get_selection_indexes(), Slic3r::ModelObject::instances, Slic3r::ModelVolume::is_any_painted(), Slic3r::ModelVolume::is_model_part(), m_objects, m_objects_model, Slic3r::ModelVolume::mesh_ptr(), Slic3r::ModelObject::name, notify_instance_updated(), object(), Slic3r::ModelObject::origin_translation, Slic3r::GUI::plater(), remove(), Slic3r::ModelVolume::restore_painting(), Slic3r::ModelVolume::save_painting(), select_item(), Slic3r::TriangleMesh::transform(), Slic3r::ModelObject::translate_instances(), and update_selections_on_canvas().

Here is the call graph for this function:

can_add_new_range_after_current()

wxString Slic3r::GUI::ObjectList::can_add_new_range_after_current

(

t_layer_height_range

current_range

)

{
    const int obj_idx = get_selected_obj_idx();
    assert(obj_idx >= 0);
    if (obj_idx < 0)
        // This should not happen.
        return "ObjectList assert";
 
    auto& ranges = object(obj_idx)->layer_config_ranges;
    auto it_range = ranges.find(current_range);
    assert(it_range != ranges.end());
    if (it_range == ranges.end())
        // This shoudl not happen.
        return "ObjectList assert";
 
    auto it_next_range = it_range;
    if (++ it_next_range == ranges.end())
      // Adding a layer after the last layer is always possible.
        return "";
 
    // BBS: remove all layer range message
 
  // All right, new layer height range could be inserted.
  return "";
}

References get_selected_obj_idx(), Slic3r::ModelObject::layer_config_ranges, and object().

Here is the call graph for this function:

can_drop()

bool Slic3r::GUI::ObjectList::can_drop ( const wxDataViewItem & item, int & src_obj_id, int & src_plate, int & dest_obj_id, int & dest_plate ) const

private

{
    if (!item.IsOk()
        || (m_objects_model->GetItemType(item) != m_dragged_data.type())
        || !(m_dragged_data.type() & (itVolume|itObject)))
        return false;
 
    if (m_dragged_data.type() & itObject){
        int from_obj_id = m_dragged_data.obj_idx();
        int to_obj_id   = m_objects_model->GetIdByItem(item);
        PartPlateList& partplate_list = wxGetApp().plater()->get_partplate_list();
 
        int from_plate = partplate_list.find_instance(from_obj_id, 0);
        if (from_plate == -1)
            return false;
        int to_plate = partplate_list.find_instance(to_obj_id, 0);
        if ((to_plate == -1) || (from_plate != to_plate))
            return false;
 
        src_obj_id = from_obj_id;
        dest_obj_id = to_obj_id;
        src_plate = from_plate;
        dest_plate = to_plate;
 
        // move instance(s) or object on "empty place" of ObjectList
        // if ( (m_dragged_data.type() & (itInstance | itObject)) && !item.IsOk() )
        //    return true;
    }
    else if (m_dragged_data.type() & itVolume) {  // move volumes inside one object only
        if (m_dragged_data.obj_idx() != m_objects_model->GetObjectIdByItem(item))
            return false;
        wxDataViewItem dragged_item = m_objects_model->GetItemByVolumeId(m_dragged_data.obj_idx(), m_dragged_data.sub_obj_idx());
        if (!dragged_item)
            return false;
        ModelVolumeType item_v_type = m_objects_model->GetVolumeType(item);
        ModelVolumeType dragged_item_v_type = m_objects_model->GetVolumeType(dragged_item);
 
        if (dragged_item_v_type == item_v_type && dragged_item_v_type != ModelVolumeType::MODEL_PART)
            return true;
 
        // Use tree item types: hidden cut connectors make tree indices differ from volumes indices.
        if (is_precise_seam(dragged_item_v_type) && is_precise_seam(item_v_type))
            // Allow reordering only within the strong or weak modifier group.
            return is_precise_seam_strong(dragged_item_v_type) == is_precise_seam_strong(item_v_type);
 
        if ((dragged_item_v_type != item_v_type) ||   // we can't reorder volumes outside of types
            item_v_type >= ModelVolumeType::SUPPORT_BLOCKER)        // support blockers/enforcers can't change its place
            return false;
 
        bool only_one_solid_part = true;
        auto& volumes = (*m_objects)[m_dragged_data.obj_idx()]->volumes;
        for (size_t cnt, id = cnt = 0; id < volumes.size() && cnt < 2; id ++)
            if (volumes[id]->type() == ModelVolumeType::MODEL_PART) {
                if (++cnt > 1)
                    only_one_solid_part = false;
            }
 
        if (dragged_item_v_type == ModelVolumeType::MODEL_PART) {
            if (only_one_solid_part)
                return false;
            return (m_objects_model->GetVolumeIdByItem(item) == 0 ||
                    (m_dragged_data.sub_obj_idx()==0 && volumes[1]->type() == ModelVolumeType::MODEL_PART) ||
                    (m_dragged_data.sub_obj_idx()!=0 && volumes[0]->type() == ModelVolumeType::MODEL_PART));
        }
        if ((dragged_item_v_type == ModelVolumeType::NEGATIVE_VOLUME || dragged_item_v_type == ModelVolumeType::PARAMETER_MODIFIER)) {
            if (only_one_solid_part)
                return false;
            return m_objects_model->GetVolumeIdByItem(item) != 0;
        }
        return false;
    }
    return true;
}

References Slic3r::GUI::PartPlateList::find_instance(), Slic3r::is_precise_seam(), Slic3r::is_precise_seam_strong(), Slic3r::GUI::itObject, Slic3r::GUI::itVolume, m_dragged_data, m_objects_model, Slic3r::MODEL_PART, Slic3r::NEGATIVE_VOLUME, Slic3r::PARAMETER_MODIFIER, and Slic3r::SUPPORT_BLOCKER.

Referenced by OnDrop(), and OnDropPossible().

Here is the call graph for this function:

Here is the caller graph for this function:

can_merge_to_multipart_object()

bool Slic3r::GUI::ObjectList::can_merge_to_multipart_object

(

)

const

{
    if (has_selected_cut_object())
        return false;
 
    if (printer_technology() == ptSLA)
        return false;
 
    wxDataViewItemArray sels;
    GetSelections(sels);
    if (sels.IsEmpty())
        return false;
 
    // should be selected just objects
    for (wxDataViewItem item : sels)
        if (!(m_objects_model->GetItemType(item) & (itObject | itInstance)))
            return false;
 
    return true;
}

References has_selected_cut_object(), Slic3r::GUI::itInstance, Slic3r::GUI::itObject, m_objects_model, Slic3r::GUI::printer_technology(), and Slic3r::ptSLA.

Here is the call graph for this function:

can_merge_to_single_object()

bool Slic3r::GUI::ObjectList::can_merge_to_single_object

(

)

const

{
    int obj_idx = get_selected_obj_idx();
    if (obj_idx < 0)
        return false;
 
    // selected object should be multipart
    return (*m_objects)[obj_idx]->volumes.size() > 1;
}

References get_selected_obj_idx(), and m_objects.

Here is the call graph for this function:

can_mesh_boolean()

bool Slic3r::GUI::ObjectList::can_mesh_boolean

(

)

const

{
    int obj_idx = get_selected_obj_idx();
    if (obj_idx < 0)
        return false;
 
    // selected object should be multi mesh
    return (*m_objects)[obj_idx]->volumes.size() > 1 || ((*m_objects)[obj_idx]->volumes.size() == 1 && (*m_objects)[obj_idx]->volumes[0]->is_splittable());
}

References get_selected_obj_idx(), is_splittable(), and m_objects.

Here is the call graph for this function:

can_paste_settings_into_list()

bool Slic3r::GUI::GUI::ObjectList::can_paste_settings_into_list

(

)

{
    wxDataViewItemArray sels;
    GetSelections(sels);
    if (sels.empty())
        return false;
    return m_clipboard.get_type() == (m_objects_model->GetItemType(sels.front()) | itSettings);
}

References Slic3r::GUI::itSettings, m_clipboard, and m_objects_model.

can_split_instances()

bool Slic3r::GUI::ObjectList::can_split_instances

(

)

{
    const Selection& selection = scene_selection();
    return selection.is_multiple_full_instance() || selection.is_single_full_instance();
}

References Slic3r::GUI::Selection::is_multiple_full_instance(), Slic3r::GUI::Selection::is_single_full_instance(), and Slic3r::GUI::scene_selection().

Here is the call graph for this function:

changed_object()

void Slic3r::GUI::ObjectList::changed_object

(

const int

obj_idx = -1

)

const

{
    wxGetApp().plater()->changed_object(obj_idx < 0 ? get_selected_obj_idx() : obj_idx);
}

References get_selected_obj_idx().

Referenced by add_layer_range_after_current(), del_instances_from_object(), del_layer_from_object(), del_layers_from_object(), del_settings_from_config(), del_subobject_from_object(), delete_all_connectors_for_object(), edit_layer_range(), edit_layer_range(), merge(), OnDrop(), paste_layers_into_list(), reorder_volumes_and_get_selection(), and split().

Here is the call graph for this function:

Here is the caller graph for this function:

check_last_selection()

bool Slic3r::GUI::ObjectList::check_last_selection

(

wxString &

msg_str

)

{
    if (!m_last_selected_item)
        return true;
 
    const bool is_shift_pressed = wxGetKeyState(WXK_SHIFT);
 
    /* We can't mix Volumes, Layers and Objects/Instances.
     * So, show information about it
     */
    const ItemType type = m_objects_model->GetItemType(m_last_selected_item);
 
    // check a case of a selection of the same type items from different Objects
    auto impossible_multi_selection = [type, this](const ItemType item_type, const SELECTION_MODE selection_mode) {
        if (!(type & item_type && m_selection_mode & selection_mode))
            return false;
 
        wxDataViewItemArray sels;
        GetSelections(sels);
        for (const auto& sel : sels)
            if (sel != m_last_selected_item &&
                m_objects_model->GetObject(sel) != m_objects_model->GetObject(m_last_selected_item))
                return true;
 
        return false;
    };
 
    if (impossible_multi_selection(itVolume, smVolume) ||
        impossible_multi_selection(itLayer,  smLayer ) ||
        type & itSettings ||
        (type & itVolume   && !(m_selection_mode & smVolume  )) ||
        (type & itLayer    && !(m_selection_mode & smLayer   )) ||
        (type & itInstance && !(m_selection_mode & smInstance))
        )
    {
        // Inform user why selection isn't completed
        // BBS: change "Object or Instance" to "Object"
        const wxString item_type = m_selection_mode & smInstance ? _(L("Object")) :
                                   m_selection_mode & smVolume   ? _(L("Part")) : _(L("Layer"));
 
        if (m_selection_mode == smInstance) {
            msg_str = wxString::Format(_(L("Selection conflicts")) + "\n\n" +
                _(L("If the first selected item is an object, the second should also be an object.")) + "\n");
        }
        else {
            msg_str = wxString::Format(_(L("Selection conflicts")) + "\n\n" +
                _(L("If the first selected item is a part, the second should be a part in the same object.")) + "\n");
        }
 
        // Unselect last selected item, if selection is without SHIFT
        if (!is_shift_pressed) {
            Unselect(m_last_selected_item);
            show_info(this, msg_str, _(L("Info")));
        }
 
        return is_shift_pressed;
    }
 
    return true;
}

References _, Slic3r::GUI::itInstance, Slic3r::GUI::itLayer, Slic3r::GUI::itSettings, Slic3r::GUI::itVolume, L, m_last_selected_item, m_objects_model, m_selection_mode, Slic3r::GUI::show_info(), smInstance, smLayer, and smVolume.

Referenced by fix_multiselection_conflicts().

Here is the call graph for this function:

Here is the caller graph for this function:

clipboard_is_empty()

bool Slic3r::GUI::ObjectList::clipboard_is_empty ( ) const

inline

{ return m_clipboard.empty(); }

References m_clipboard.

clone()

void Slic3r::GUI::ObjectList::clone

(

)

{
    wxPostEvent((wxEvtHandler*)wxGetApp().plater()->canvas3D()->get_wxglcanvas(), SimpleEvent(EVT_GLTOOLBAR_CLONE));
}

References Slic3r::GUI::plater().

Referenced by dispatch_shortcut().

Here is the call graph for this function:

Here is the caller graph for this function:

config()

ModelConfig * Slic3r::GUI::ObjectList::config ( ) const

inline

{ return m_config; }

References m_config.

Referenced by add_layer_item(), add_settings_item(), copy_settings_to_clipboard(), edit_layer_range(), edit_layer_range(), get_default_layer_config(), merge(), paste_settings_into_list(), set_extruder_for_selected_items(), split(), and update_filament_in_config().

Here is the caller graph for this function:

copy()

void Slic3r::GUI::ObjectList::copy

(

)

{
    wxPostEvent((wxEvtHandler*)wxGetApp().plater()->canvas3D()->get_wxglcanvas(), SimpleEvent(EVT_GLTOOLBAR_COPY));
}

References Slic3r::GUI::plater().

Referenced by dispatch_shortcut().

Here is the call graph for this function:

Here is the caller graph for this function:

copy_layers_to_clipboard()

void Slic3r::GUI::ObjectList::copy_layers_to_clipboard

(

)

{
    wxDataViewItemArray sel_layers;
    GetSelections(sel_layers);
 
    const int obj_idx = m_objects_model->GetObjectIdByItem(sel_layers.front());
    if (obj_idx < 0 || (int)m_objects->size() <= obj_idx)
        return;
 
    const t_layer_config_ranges& ranges = object(obj_idx)->layer_config_ranges;
    t_layer_config_ranges& cache_ranges = m_clipboard.get_ranges_cache();
 
    if (sel_layers.Count() == 1 && m_objects_model->GetItemType(sel_layers.front()) & itLayerRoot)
    {
        cache_ranges.clear();
        cache_ranges = ranges;
        return;
    }
 
    for (const auto& layer_item : sel_layers)
        if (m_objects_model->GetItemType(layer_item) & itLayer) {
            auto range = m_objects_model->GetLayerRangeByItem(layer_item);
            auto it = ranges.find(range);
            if (it != ranges.end())
                cache_ranges[it->first] = it->second;
        }
}

References Slic3r::GUI::itLayer, Slic3r::GUI::itLayerRoot, Slic3r::ModelObject::layer_config_ranges, m_clipboard, m_objects, m_objects_model, object(), and Slic3r::range().

Referenced by copy_to_clipboard().

Here is the call graph for this function:

Here is the caller graph for this function:

copy_settings_to_clipboard()

void Slic3r::GUI::ObjectList::copy_settings_to_clipboard

(

)

{
    wxDataViewItem item = GetSelection();
    assert(item.IsOk());
    if (m_objects_model->GetItemType(item) & itSettings)
        item = m_objects_model->GetParent(item);
 
    wxDataViewItemArray items;
    items.push_back(item);
    while ((m_objects_model->GetItemType(items.back()) & itObject) == 0) {
        if (m_objects_model->GetItemType(items.back()) & itLayerRoot)
            items.back() = m_objects_model->GetParent(items.back());
        else
            items.push_back(m_objects_model->GetParent(items.back()));
    }
    auto &config = m_clipboard.get_config_cache();
    config.clear();
    while (!items.empty()) {
        config.apply(get_item_config(items.back()).get());
        items.pop_back();
    }
 
    m_clipboard.set_type(ItemType(m_objects_model->GetItemType(item) | itSettings));
}

References config(), Slic3r::ModelConfig::get(), get_item_config(), Slic3r::GUI::itLayerRoot, Slic3r::GUI::itObject, Slic3r::GUI::itSettings, m_clipboard, and m_objects_model.

Referenced by copy_to_clipboard().

Here is the call graph for this function:

Here is the caller graph for this function:

copy_to_clipboard()

bool Slic3r::GUI::ObjectList::copy_to_clipboard

(

)

{
    wxDataViewItemArray sels;
    GetSelections(sels);
    if (sels.IsEmpty())
        return false;
    ItemType type = m_objects_model->GetItemType(sels.front());
    if (!(type & (itSettings | itLayer | itLayerRoot))) {
        m_clipboard.reset();
        return false;
    }
 
    if (type & itSettings)
        copy_settings_to_clipboard();
    if (type & (itLayer | itLayerRoot))
        copy_layers_to_clipboard();
 
    m_clipboard.set_type(type);
    return true;
}

References copy_layers_to_clipboard(), copy_settings_to_clipboard(), Slic3r::GUI::itLayer, Slic3r::GUI::itLayerRoot, Slic3r::GUI::itSettings, m_clipboard, and m_objects_model.

Referenced by cut_to_clipboard().

Here is the call graph for this function:

Here is the caller graph for this function:

create_objects_ctrl()

void Slic3r::GUI::ObjectList::create_objects_ctrl

(

)

{
    // BBS
#if 0
    /* Temporary workaround for the correct behavior of the Scrolled sidebar panel:
     * 1. set a height of the list to some big value
     * 2. change it to the normal(meaningful) min value after first whole Mainframe updating/layouting
     */
    SetMinSize(wxSize(-1, 3000));
#endif
 
    m_objects_model = new ObjectDataViewModel;
    AssociateModel(m_objects_model);
    m_objects_model->SetAssociatedControl(this);
#if wxUSE_DRAG_AND_DROP && wxUSE_UNICODE
    EnableDragSource(wxDF_UNICODETEXT);
    EnableDropTarget(wxDF_UNICODETEXT);
#endif // wxUSE_DRAG_AND_DROP && wxUSE_UNICODE
 
    const int em = wxGetApp().em_unit();
 
    m_columns_width.resize(colCount);
    m_columns_width[colName] = 22;
    m_columns_width[colHeight] = 3;
    m_columns_width[colPrint] = 3;
    m_columns_width[colFilament] = 5;
    m_columns_width[colSupportPaint] = 3;
    m_columns_width[colSinking] = 3;
    m_columns_width[colColorPaint] = 3;
    m_columns_width[colEditing] = 3;
 
    // column ItemName(Icon+Text) of the view control:
    // And Icon can be consisting of several bitmaps
    BitmapTextRenderer* bmp_text_renderer = new BitmapTextRenderer();
    bmp_text_renderer->set_can_create_editor_ctrl_function([this]() {
        auto type = m_objects_model->GetItemType(GetSelection());
        return type & (itVolume | itObject | itPlate);
    });
 
    // BBS
    wxDataViewColumn* name_col = new wxDataViewColumn(_L("Name"), bmp_text_renderer,
        colName, m_columns_width[colName] * em, wxALIGN_LEFT, wxDATAVIEW_COL_RESIZABLE);
    //name_col->SetBitmap(create_scaled_bitmap("organize", nullptr, FromDIP(18)));
    AppendColumn(name_col);
 
    // column Variable height Property (Icon) of the view control:
    AppendBitmapColumn(" ", colHeight, wxOSX ? wxDATAVIEW_CELL_EDITABLE : wxDATAVIEW_CELL_INERT, 3 * em,
        wxALIGN_CENTER_HORIZONTAL, 0);
 
    // column PrintableProperty (Icon) of the view control:
    AppendBitmapColumn(" ", colPrint, wxOSX ? wxDATAVIEW_CELL_EDITABLE : wxDATAVIEW_CELL_INERT, m_columns_width[colPrint]*em,
        wxALIGN_CENTER_HORIZONTAL, 0);
 
    // column Extruder of the view control:
    BitmapChoiceRenderer* bmp_choice_renderer = new BitmapChoiceRenderer();
    const auto get_filament_context_item = [this]() {
#ifdef __WXOSX__
        return m_filament_editor_item.IsOk() ? m_filament_editor_item : GetSelection();
#else
        return GetSelection();
#endif
    };
    bmp_choice_renderer->set_can_create_editor_ctrl_function([this, get_filament_context_item]() {
        const wxDataViewItem item = get_filament_context_item();
        return m_objects_model->GetItemType(item) & (itVolume | itLayer | itObject);
    });
    bmp_choice_renderer->set_default_extruder_idx([this, get_filament_context_item]() {
        const wxDataViewItem item = get_filament_context_item();
        return m_objects_model->GetDefaultExtruderIdx(item);
    });
    bmp_choice_renderer->set_has_default_extruder([this, get_filament_context_item]() {
        const wxDataViewItem item = get_filament_context_item();
        return m_objects_model->GetVolumeType(item) == ModelVolumeType::PARAMETER_MODIFIER ||
               m_objects_model->GetItemType(item) == itLayer;
    });
    AppendColumn(new wxDataViewColumn(_L("Fila."), bmp_choice_renderer,
        colFilament, m_columns_width[colFilament] * em, wxALIGN_CENTER_HORIZONTAL, 0));
 
    // BBS
    AppendBitmapColumn(" ", colSupportPaint, wxOSX ? wxDATAVIEW_CELL_EDITABLE : wxDATAVIEW_CELL_INERT, m_columns_width[colSupportPaint] * em,
        wxALIGN_CENTER_HORIZONTAL, 0);
    AppendBitmapColumn(" ", colColorPaint, wxOSX ? wxDATAVIEW_CELL_EDITABLE : wxDATAVIEW_CELL_INERT, m_columns_width[colColorPaint] * em,
        wxALIGN_CENTER_HORIZONTAL, 0);
    AppendBitmapColumn(" ", colSinking, wxOSX ? wxDATAVIEW_CELL_EDITABLE : wxDATAVIEW_CELL_INERT, m_columns_width[colSinking] * em,
        wxALIGN_CENTER_HORIZONTAL, 0);
 
    // column ItemEditing of the view control:
    AppendBitmapColumn(" ", colEditing, wxOSX ? wxDATAVIEW_CELL_EDITABLE : wxDATAVIEW_CELL_INERT, m_columns_width[colEditing] * em,
        wxALIGN_CENTER_HORIZONTAL, 0);
 
 
    // On macOS, bypass wxDataViewCtrl::EditItem() for this custom renderer to avoid
    // native text editing of wxCustomRendererObject.
    this->Bind(wxEVT_DATAVIEW_ITEM_ACTIVATED, [this](wxDataViewEvent& event) {
        if (event.GetColumn() == colFilament) {
#ifdef __WXOSX__
            start_filament_editor(event.GetItem());
#else
            // Trigger the editor opening manually
            this->EditItem(event.GetItem(), GetColumn(colFilament));
#endif
            return;
        }
 
        // Double-clicking an object/part/instance row frames it in the 3D view,
        // matching the "Fit camera to scene or selected object" canvas button.
        // The preceding single click has already synced the canvas selection via
        // wxEVT_DATAVIEW_SELECTION_CHANGED, so we just trigger the zoom here.
        // No-op in slice-preview mode: the camera is shared with the editor
        // canvas, so zooming there would move the preview view too — and the
        // preview canvas's own toolbar button intentionally resets to the bed.
        const wxDataViewItem item = event.GetItem();
        if (!item.IsOk())
            return;
        if (wxGetApp().plater()->is_preview_shown())
            return;
        const ItemType type = m_objects_model->GetItemType(item);
        if (type & (itObject | itVolume | itInstance)) {
            if (GLCanvas3D* canvas = wxGetApp().plater()->get_current_canvas3D())
                canvas->zoom_to_selection();
        }
    });
 
    //for (int cn = colName; cn < colCount; cn++) {
    //    GetColumn(cn)->SetResizeable(cn == colName);
    //}
 
    // For some reason under OSX on 4K(5K) monitors in wxDataViewColumn constructor doesn't set width of column.
    // Therefore, force set column width.
#ifdef __WXOSX__
        dataview_remove_insets(this);
        for (int cn = colName; cn < colCount; cn++)
            GetColumn(cn)->SetWidth(m_columns_width[cn] * em);
#endif
 
    // Force an explicit row height on all platforms so the object-list spacing is
    // consistent and the filament colour badge (2*em tall, see
    // get_extruder_color_icons()) always fits. This is required on macOS, where wx
    // 3.3's native wxDataViewCtrl uses a fixed font-line-height row and does NOT
    // grow it to fit custom renderers' GetSize() (badges would otherwise overflow
    // and merge into adjacent rows); on Windows/Linux the generic control normally
    // derives the height from the renderers, but we set it here too so all
    // platforms match.
    SetRowHeight(2 * em + FromDIP(2));
}

References _L, Slic3r::GUI::colColorPaint, Slic3r::GUI::colCount, Slic3r::GUI::colEditing, Slic3r::GUI::colFilament, Slic3r::GUI::colHeight, Slic3r::GUI::colName, Slic3r::GUI::colPrint, Slic3r::GUI::colSinking, Slic3r::GUI::colSupportPaint, Slic3r::GUI::dataview_remove_insets(), Slic3r::GUI::itInstance, Slic3r::GUI::itLayer, Slic3r::GUI::itObject, Slic3r::GUI::itPlate, Slic3r::GUI::itVolume, m_columns_width, m_objects_model, Slic3r::PARAMETER_MODIFIER, Slic3r::GUI::plater(), BitmapChoiceRenderer::set_can_create_editor_ctrl_function(), BitmapTextRenderer::set_can_create_editor_ctrl_function(), BitmapChoiceRenderer::set_default_extruder_idx(), BitmapChoiceRenderer::set_has_default_extruder(), and wxOSX.

Referenced by ObjectList().

Here is the call graph for this function:

Here is the caller graph for this function:

cut()

void Slic3r::GUI::ObjectList::cut

(

)

{
    wxPostEvent((wxEvtHandler*)wxGetApp().plater()->canvas3D()->get_wxglcanvas(), SimpleEvent(EVT_GLTOOLBAR_CUT));
}

References Slic3r::GUI::plater().

Referenced by dispatch_shortcut().

Here is the call graph for this function:

Here is the caller graph for this function:

cut_to_clipboard()

bool Slic3r::GUI::ObjectList::cut_to_clipboard

(

)

{
    return copy_to_clipboard();
}

References copy_to_clipboard().

Here is the call graph for this function:

decrease_instances()

void Slic3r::GUI::ObjectList::decrease_instances

(

)

{
    wxGetApp().plater()->decrease_instances(1);
}

Referenced by dispatch_shortcut().

Here is the caller graph for this function:

decrease_object_instances()

void Slic3r::GUI::ObjectList::decrease_object_instances	(	const size_t	obj_idx,
		const size_t	num )

{
    select_item([this, obj_idx, num]() { return m_objects_model->DeleteLastInstance(m_objects_model->GetItemById(obj_idx), num); });
}

References m_objects_model, and select_item().

Referenced by Slic3r::GUI::Plater::decrease_instances().

Here is the call graph for this function:

Here is the caller graph for this function:

del_from_cut_object()

bool Slic3r::GUI::ObjectList::del_from_cut_object	(	bool	is_connector,
		bool	is_model_part = false,
		bool	is_negative_volume = false )

{
    const long buttons_style = is_cut_connector   ? (wxYES | wxNO | wxCANCEL) : (wxYES | wxCANCEL);
 
    const wxString title     = is_cut_connector   ? _L("Delete connector from object which is a part of cut") :
                               is_model_part      ? _L("Delete solid part from object which is a part of cut") :
                               is_negative_volume ? _L("Delete negative volume from object which is a part of cut") : "";
                             
    const wxString msg_end   = is_cut_connector   ? ("\n" + _L("To save cut correspondence you can delete all connectors from all related objects.")) : "";
 
    InfoDialog dialog(wxGetApp().plater(), title,
                      (_L("This action will break a cut correspondence.\nAfter that, model consistency can\'t be guaranteed.\n\nTo manipulate with solid parts or negative volumes you have to invalidate cut information first.") + msg_end ),
                      false, buttons_style | wxCANCEL_DEFAULT | wxICON_WARNING);
 
    dialog.SetButtonLabel(wxID_YES, _L("Invalidate cut info"));
    if (is_cut_connector)
        dialog.SetButtonLabel(wxID_NO, _L("Delete all connectors"));
 
    const int answer = dialog.ShowModal();
    if (answer == wxID_CANCEL)
        return false;
 
    if (answer == wxID_YES)
        invalidate_cut_info_for_selection();
    else if (answer == wxID_NO)
        delete_all_connectors_for_selection();
    return true;
}

References _L, delete_all_connectors_for_selection(), invalidate_cut_info_for_selection(), Slic3r::GUI::plater(), Slic3r::GUI::MsgDialog::SetButtonLabel(), and Slic3r::GUI::DPIAware< P >::ShowModal().

Referenced by del_info_item(), and del_subobject_from_object().

Here is the call graph for this function:

Here is the caller graph for this function:

del_info_item()

void Slic3r::GUI::ObjectList::del_info_item	(	const int	obj_idx,
		InfoItemType	type )

{
    Plater* plater = wxGetApp().plater();
    GLCanvas3D* cnv = plater->canvas3D();
 
    switch (type) {
    case InfoItemType::CustomSupports: {
        cnv->get_gizmos_manager().reset_all_states();
        Plater::TakeSnapshot snapshot(plater, "Remove support painting");
        for (ModelVolume* mv : (*m_objects)[obj_idx]->volumes)
            mv->supported_facets.reset();
        break;
    }
 
    // BBS: remove CustomSeam
 
    case InfoItemType::CutConnectors:
        if (!del_from_cut_object(true)) {
            // there is no need to post EVT_GLCANVAS_SCHEDULE_BACKGROUND_PROCESS if nothing was changed
            return;
        }
        break;
 
    case InfoItemType::MmSegmentation: {
        cnv->get_gizmos_manager().reset_all_states();
        Plater::TakeSnapshot snapshot(plater, "Remove color painting");
        for (ModelVolume* mv : (*m_objects)[obj_idx]->volumes)
            mv->mmu_segmentation_facets.reset();
        break;
    }
 
    case InfoItemType::FuzzySkin: {
        cnv->get_gizmos_manager().reset_all_states();
        Plater::TakeSnapshot snapshot(plater, _u8L("Remove paint-on fuzzy skin"));
        for (ModelVolume* mv : (*m_objects)[obj_idx]->volumes)
            mv->fuzzy_skin_facets.reset();
        break;
    }
 
    // BBS: remove Sinking
    case InfoItemType::Undef : assert(false); break;
    }
    cnv->post_event(SimpleEvent(EVT_GLCANVAS_SCHEDULE_BACKGROUND_PROCESS));
}

References _u8L, Slic3r::GUI::CustomSupports, Slic3r::GUI::CutConnectors, del_from_cut_object(), Slic3r::GUI::FuzzySkin, Slic3r::GUI::GLCanvas3D::get_gizmos_manager(), m_objects, Slic3r::GUI::MmSegmentation, Slic3r::GUI::plater(), Slic3r::GUI::GLCanvas3D::post_event(), Slic3r::GUI::GLGizmosManager::reset_all_states(), and Slic3r::GUI::Undef.

Referenced by del_subobject_item().

Here is the call graph for this function:

Here is the caller graph for this function:

del_instances_from_object()

void Slic3r::GUI::ObjectList::del_instances_from_object

(

const int

obj_idx

)

{
    auto& instances = (*m_objects)[obj_idx]->instances;
    if (instances.size() <= 1)
        return;
 
    // BBS: remove snapshot name "Delete All Instances from Object"
    take_snapshot("");
 
    while ( instances.size()> 1)
        instances.pop_back();
 
    (*m_objects)[obj_idx]->invalidate_bounding_box(); // ? #ys_FIXME
 
    changed_object(obj_idx);
}

References changed_object(), and Slic3r::GUI::take_snapshot().

Referenced by del_subobject_item().

Here is the call graph for this function:

Here is the caller graph for this function:

del_layer_from_object()

void Slic3r::GUI::ObjectList::del_layer_from_object	(	const int	obj_idx,
		const t_layer_height_range &	layer_range )

{
    const auto del_range = object(obj_idx)->layer_config_ranges.find(layer_range);
    if (del_range == object(obj_idx)->layer_config_ranges.end())
        return;
 
    take_snapshot(_u8L("Remove height range"));
 
    object(obj_idx)->layer_config_ranges.erase(del_range);
 
    changed_object(obj_idx);
}

References _u8L, changed_object(), Slic3r::ModelObject::layer_config_ranges, object(), and Slic3r::GUI::take_snapshot().

Referenced by del_subobject_item().

Here is the call graph for this function:

Here is the caller graph for this function:

del_layer_range()

void Slic3r::GUI::ObjectList::del_layer_range

(

const t_layer_height_range &

range

)

{
    const int obj_idx = get_selected_obj_idx();
    if (obj_idx < 0) return;
 
    t_layer_config_ranges& ranges = object(obj_idx)->layer_config_ranges;
 
    wxDataViewItem selectable_item = GetSelection();
 
    if (ranges.size() == 1)
        selectable_item = m_objects_model->GetParent(selectable_item);
 
    wxDataViewItem layer_item = m_objects_model->GetItemByLayerRange(obj_idx, range);
    del_subobject_item(layer_item);
 
    select_item(selectable_item);
}

References del_subobject_item(), get_selected_obj_idx(), Slic3r::ModelObject::layer_config_ranges, m_objects_model, object(), Slic3r::range(), and select_item().

Here is the call graph for this function:

del_layers_from_object()

void Slic3r::GUI::ObjectList::del_layers_from_object

(

const int

obj_idx

)

{
    object(obj_idx)->layer_config_ranges.clear();
 
    changed_object(obj_idx);
}

References changed_object(), Slic3r::ModelObject::layer_config_ranges, and object().

Referenced by del_subobject_item().

Here is the call graph for this function:

Here is the caller graph for this function:

del_object()

bool Slic3r::GUI::ObjectList::del_object	(	const int	obj_idx,
		bool	refresh_immediately = true )

{
    return wxGetApp().plater()->delete_object_from_model(obj_idx, refresh_immediately);
}

Referenced by delete_from_model_and_list(), and delete_from_model_and_list().

Here is the caller graph for this function:

del_settings_from_config()

void Slic3r::GUI::ObjectList::del_settings_from_config

(

const wxDataViewItem &

parent_item

)

{
    const bool is_layer_settings = m_objects_model->GetItemType(parent_item) == itLayer;
 
    const size_t opt_cnt = m_config->keys().size();
    if ((opt_cnt == 1 && m_config->has("extruder")) ||
        (is_layer_settings && opt_cnt == 2 && m_config->has("extruder") && m_config->has("layer_height")))
        return;
 
    take_snapshot(_u8L("Delete Settings"));
 
    int extruder = m_config->has("extruder") ? m_config->extruder() : -1;
 
    coordf_t layer_height = 0.0;
    if (is_layer_settings)
        layer_height = m_config->opt_float("layer_height");
 
    m_config->reset();
 
    if (extruder >= 0)
        m_config->set_key_value("extruder", new ConfigOptionInt(extruder));
    if (is_layer_settings)
        m_config->set_key_value("layer_height", new ConfigOptionFloat(layer_height));
 
    changed_object();
}

References _u8L, changed_object(), Slic3r::ConfigOptionFloat, Slic3r::GUI::itLayer, Slic3r::GUI::layer_height, m_config, m_objects_model, and Slic3r::GUI::take_snapshot().

Referenced by del_subobject_item().

Here is the call graph for this function:

Here is the caller graph for this function:

del_subobject_from_object()

bool Slic3r::GUI::ObjectList::del_subobject_from_object	(	const int	obj_idx,
		const int	idx,
		const int	type )

{
    assert(idx >= 0);
 
    // BBS: support partplage logic
    int n_plates = wxGetApp().plater()->get_partplate_list().get_plate_count();
  if ((obj_idx >= 1000 && obj_idx < 1000 + n_plates) || idx<0)
    // Cannot delete a wipe tower or volume with negative id
    return false;
 
    ModelObject* object = (*m_objects)[obj_idx];
 
    if (type == itVolume) {
        const auto volume = object->volumes[idx];
 
        // if user is deleting the last solid part, throw error
        int solid_cnt = 0;
        for (auto vol : object->volumes)
            if (vol->is_model_part())
                ++solid_cnt;
        if (volume->is_model_part() && solid_cnt == 1) {
            Slic3r::GUI::show_error(nullptr, _L("Deleting the last solid part is not allowed."));
            return false;
        }
        if (object->is_cut() && (volume->is_model_part() || volume->is_negative_volume())) {
            del_from_cut_object(volume->is_cut_connector(), volume->is_model_part(), volume->is_negative_volume());
            // in any case return false to break the deletion
            return false;
        }
 
        take_snapshot(_u8L("Delete part"));
 
        object->delete_volume(idx);
 
        if (object->volumes.size() == 1) {
            const auto last_volume = object->volumes[0];
            if (!last_volume->config.empty()) {
                object->config.apply(last_volume->config);
                last_volume->config.reset();
 
                // update extruder color in ObjectList
                wxDataViewItem obj_item = m_objects_model->GetItemById(obj_idx);
                if (obj_item) {
                    // BBS
                    if (last_volume->config.has("extruder")) {
                        int extruder_id = last_volume->config.opt_int("extruder");
                        object->config.set("extruder", extruder_id);
                    }
                    wxString extruder = object->config.has("extruder") ? wxString::Format("%d", object->config.extruder()) : _devL("1");
                    m_objects_model->SetExtruder(extruder, obj_item);
                }
                // add settings to the object, if it has them
                add_settings_item(obj_item, &object->config.get());
            }
        }
        //BBS: notify partplate the modify
        notify_instance_updated(obj_idx);
    }
    else if (type == itInstance) {
        if (object->instances.size() == 1) {
            // BBS: remove snapshot name "Last instance of an object cannot be deleted."
            Slic3r::GUI::show_error(nullptr, "");
            return false;
        }
 
        // BBS: remove snapshot name "Delete Instance"
        take_snapshot("");
        object->delete_instance(idx);
    }
    else
        return false;
 
    changed_object(obj_idx);
 
    return true;
}

References _devL, _L, _u8L, add_settings_item(), changed_object(), del_from_cut_object(), Slic3r::GUI::itInstance, Slic3r::GUI::itVolume, m_objects_model, notify_instance_updated(), object(), Slic3r::GUI::show_error(), and Slic3r::GUI::take_snapshot().

Referenced by del_subobject_item(), delete_from_model_and_list(), delete_from_model_and_list(), instances_to_separated_object(), and instances_to_separated_objects().

Here is the call graph for this function:

Here is the caller graph for this function:

del_subobject_item()

void Slic3r::GUI::ObjectList::del_subobject_item

(

wxDataViewItem &

item

)

{
    if (!item) return;
 
    int obj_idx, idx;
    ItemType type;
 
    m_objects_model->GetItemInfo(item, type, obj_idx, idx);
    if (type == itUndef)
        return;
 
    wxDataViewItem parent = m_objects_model->GetParent(item);
 
    InfoItemType item_info_type = m_objects_model->GetInfoItemType(item);
    if (type & itSettings)
        del_settings_from_config(parent);
    else if (type & itInstanceRoot && obj_idx != -1)
        del_instances_from_object(obj_idx);
    else if (type & itLayerRoot && obj_idx != -1)
        del_layers_from_object(obj_idx);
    else if (type & itLayer && obj_idx != -1)
        del_layer_from_object(obj_idx, m_objects_model->GetLayerRangeByItem(item));
    else if (type & itInfo && obj_idx != -1)
        del_info_item(obj_idx, item_info_type);
    else if (idx == -1)
        return;
    else if (!del_subobject_from_object(obj_idx, idx, type))
        return;
 
    // If last volume item with warning was deleted, unmark object item
    if (type & itVolume) {
        const std::string& icon_name = get_warning_icon_name(object(obj_idx)->get_object_stl_stats());
        m_objects_model->UpdateWarningIcon(parent, icon_name);
    }
 
    if (!(type & itInfo) || item_info_type != InfoItemType::CutConnectors) {
        // Connectors Item is already updated/deleted inside the del_info_item()
        m_objects_model->Delete(item);
        update_info_items(obj_idx);
    }
}

References Slic3r::GUI::CutConnectors, del_info_item(), del_instances_from_object(), del_layer_from_object(), del_layers_from_object(), del_settings_from_config(), del_subobject_from_object(), Slic3r::GUI::get_warning_icon_name(), Slic3r::GUI::itInfo, Slic3r::GUI::itInstanceRoot, Slic3r::GUI::itLayer, Slic3r::GUI::itLayerRoot, Slic3r::GUI::itSettings, Slic3r::GUI::itUndef, Slic3r::GUI::itVolume, m_objects_model, and update_info_items().

Referenced by add_layer_range_after_current(), del_layer_range(), and remove().

Here is the call graph for this function:

Here is the caller graph for this function:

delete_all_connectors_for_object()

void Slic3r::GUI::ObjectList::delete_all_connectors_for_object

(

int

obj_idx

)

{
    ModelObject* init_obj = object(obj_idx);
    if (!init_obj->is_cut())
        return;
 
    take_snapshot(_u8L("Delete all connectors"));
 
    const CutObjectBase cut_id = init_obj->cut_id;
    // Delete all connectors for related objects (which have the same cut_id)
    Model& model = wxGetApp().plater()->model();
    for (int idx = int(m_objects->size())-1; idx >= 0; idx--)
        if (ModelObject* obj = object(idx); obj->cut_id.is_equal(cut_id)) {
            obj->delete_connectors();
 
            if (obj->volumes.empty() || !obj->has_solid_mesh()) {
                const std::string deleted_obj_name = obj->name;
                model.delete_object(idx);
                {
                    Slic3r::LifecycleEventContext ctx;
                    ctx.name = deleted_obj_name;
                    ctx.code = Slic3r::LifecycleEvtCode::Ok;
                    Slic3r::fire_lifecycle_event(Slic3r::LifecycleEvent::ObjectDeleted, ctx);
                }
                m_objects_model->Delete(m_objects_model->GetItemById(idx));
                continue;
            }
 
            update_info_items(idx);
            add_volumes_to_object_in_list(idx);
            changed_object(int(idx));
        }
 
    update_lock_icons_for_model();
}

References _u8L, add_volumes_to_object_in_list(), changed_object(), Slic3r::LifecycleEventContext::code, Slic3r::ModelObject::cut_id, Slic3r::Model::delete_object(), Slic3r::fire_lifecycle_event(), Slic3r::ModelObject::is_cut(), Slic3r::CutObjectBase::is_equal(), m_objects, m_objects_model, Slic3r::LifecycleEventContext::name, object(), Slic3r::ObjectDeleted, Slic3r::Ok, Slic3r::GUI::take_snapshot(), update_info_items(), and update_lock_icons_for_model().

Referenced by delete_all_connectors_for_selection().

Here is the call graph for this function:

Here is the caller graph for this function:

delete_all_connectors_for_selection()

void Slic3r::GUI::ObjectList::delete_all_connectors_for_selection

(

)

{
    const wxDataViewItem item = GetSelection();
    if (item) {
        const int obj_idx = m_objects_model->GetObjectIdByItem(item);
        if (obj_idx >= 0)
            delete_all_connectors_for_object(size_t(obj_idx));
    }
}

References delete_all_connectors_for_object(), and m_objects_model.

Referenced by del_from_cut_object().

Here is the call graph for this function:

Here is the caller graph for this function:

delete_all_objects_from_list()

void Slic3r::GUI::ObjectList::delete_all_objects_from_list

(

)

{
    m_prevent_list_events = true;
    reload_all_plates();
    m_prevent_list_events = false;
    part_selection_changed();
}

References m_prevent_list_events, part_selection_changed(), and reload_all_plates().

Here is the call graph for this function:

delete_from_model_and_list() [1/2]

void Slic3r::GUI::ObjectList::delete_from_model_and_list	(	const ItemType	type,
		const int	obj_idx,
		const int	sub_obj_idx )

{
    if (!(type&(itObject|itVolume|itInstance)))
        return;
 
    take_snapshot(_u8L("Delete selected"));
 
    if (type&itObject) {
        bool was_cut = object(obj_idx)->is_cut();
        // For variable layer height, the size of layer data is larger than 4
        bool vari_layer_height = (object(obj_idx)->layer_height_profile.get().size() > 4);
        if (del_object(obj_idx)) {
            delete_object_from_list(obj_idx);
            if (was_cut)
                update_lock_icons_for_model();
            if (vari_layer_height) {
                m_variable_layer_obj_num--;
                set_variable_height_column_hidden(m_variable_layer_obj_num == 0);
            }
        }
    }
    else {
        del_subobject_from_object(obj_idx, sub_obj_idx, type);
 
        type == itVolume ? delete_volume_from_list(obj_idx, sub_obj_idx) :
            delete_instance_from_list(obj_idx, sub_obj_idx);
    }
}

References _u8L, del_object(), del_subobject_from_object(), delete_instance_from_list(), delete_object_from_list(), delete_volume_from_list(), Slic3r::LayerHeightProfile::get(), Slic3r::ModelObject::is_cut(), Slic3r::GUI::itInstance, Slic3r::GUI::itObject, Slic3r::GUI::itVolume, Slic3r::ModelObject::layer_height_profile, m_variable_layer_obj_num, object(), set_variable_height_column_hidden(), Slic3r::GUI::take_snapshot(), and update_lock_icons_for_model().

Referenced by remove().

Here is the call graph for this function:

Here is the caller graph for this function:

delete_from_model_and_list() [2/2]

void Slic3r::GUI::ObjectList::delete_from_model_and_list

(

const std::vector< ItemForDelete > &

items_for_delete

)

{
    if (items_for_delete.empty())
        return;
 
    m_prevent_list_events = true;
    //BBS
    bool need_update = false;
 
    std::set<size_t> modified_objects_ids;
    for (std::vector<ItemForDelete>::const_reverse_iterator item = items_for_delete.rbegin(); item != items_for_delete.rend(); ++item) {
        if (!(item->type&(itObject | itVolume | itInstance)))
            continue;
        if (item->type&itObject) {
            // refresh after del_object
            need_update = true;
            bool refresh_immediately = false;
            bool was_cut = object(item->obj_idx)->is_cut();
            // For variable layer height, the size of layer data is larger than 4
            bool vari_layer_height = (object(item->obj_idx)->layer_height_profile.get().size() > 4);
            if (!del_object(item->obj_idx, refresh_immediately))
                return;
            m_objects_model->Delete(m_objects_model->GetItemById(item->obj_idx));
            if (was_cut)
                update_lock_icons_for_model();
            if (vari_layer_height) {
                m_variable_layer_obj_num--;
                set_variable_height_column_hidden(m_variable_layer_obj_num == 0);
            }
        }
        else {
            if (!del_subobject_from_object(item->obj_idx, item->sub_obj_idx, item->type))
                return; //continue;
            if (item->type&itVolume) {
                m_objects_model->Delete(m_objects_model->GetItemByVolumeId(item->obj_idx, item->sub_obj_idx));
                // BBS
#if 0
                ModelObject* obj = object(item->obj_idx);
                if (obj->volumes.size() == 1) {
                    wxDataViewItem parent = m_objects_model->GetItemById(item->obj_idx);
                    if (obj->config.has("extruder")) {
                        const wxString extruder = wxString::Format("%d", obj->config.extruder());
                        m_objects_model->SetExtruder(extruder, parent);
                    }
                    // If last volume item with warning was deleted, unmark object item
                    m_objects_model->UpdateWarningIcon(parent, get_warning_icon_name(obj->get_object_stl_stats()));
                }
#endif
                wxGetApp().plater()->canvas3D()->ensure_on_bed(item->obj_idx, printer_technology() != ptSLA);
            }
            else
                m_objects_model->Delete(m_objects_model->GetItemByInstanceId(item->obj_idx, item->sub_obj_idx));
        }
 
        modified_objects_ids.insert(static_cast<size_t>(item->obj_idx));
    }
 
    if (need_update) {
        wxGetApp().plater()->update();
        wxGetApp().plater()->object_list_changed();
    }
 
    for (size_t id : modified_objects_ids) {
        update_info_items(id);
    }
 
    m_prevent_list_events = true;
    part_selection_changed();
}

References Slic3r::ModelObject::config, del_object(), del_subobject_from_object(), Slic3r::ModelConfig::extruder(), Slic3r::LayerHeightProfile::get(), Slic3r::ModelObject::get_object_stl_stats(), Slic3r::GUI::get_warning_icon_name(), Slic3r::ModelConfig::has(), Slic3r::ModelObject::is_cut(), Slic3r::GUI::itInstance, Slic3r::GUI::itObject, Slic3r::GUI::itVolume, Slic3r::ModelObject::layer_height_profile, m_objects_model, m_prevent_list_events, m_variable_layer_obj_num, object(), part_selection_changed(), Slic3r::GUI::printer_technology(), Slic3r::ptSLA, set_variable_height_column_hidden(), update_info_items(), update_lock_icons_for_model(), and Slic3r::ModelObject::volumes.

Here is the call graph for this function:

delete_instance_from_list()

void Slic3r::GUI::ObjectList::delete_instance_from_list	(	const size_t	obj_idx,
		const size_t	inst_idx )

{
    select_item([this, obj_idx, inst_idx]() { return m_objects_model->Delete(m_objects_model->GetItemByInstanceId(obj_idx, inst_idx)); });
}

References m_objects_model, and select_item().

Referenced by delete_from_model_and_list(), instances_to_separated_object(), and instances_to_separated_objects().

Here is the call graph for this function:

Here is the caller graph for this function:

delete_object_from_list() [1/2]

void Slic3r::GUI::ObjectList::delete_object_from_list

(

)

{
    auto item = GetSelection();
    if (!item)
        return;
    if (m_objects_model->GetParent(item) == wxDataViewItem(nullptr))
        select_item([this, item]() { return m_objects_model->Delete(item); });
    else
        select_item([this, item]() { return m_objects_model->Delete(m_objects_model->GetParent(item)); });
}

References m_objects_model, and select_item().

Referenced by Slic3r::GUI::Plater::apply_cut_object_to_model(), and delete_from_model_and_list().

Here is the call graph for this function:

Here is the caller graph for this function:

delete_object_from_list() [2/2]

void Slic3r::GUI::ObjectList::delete_object_from_list

(

const size_t

obj_idx

)

{
    select_item([this, obj_idx]() { return m_objects_model->Delete(m_objects_model->GetItemById(obj_idx)); });
}

References m_objects_model, and select_item().

Here is the call graph for this function:

delete_volume_from_list()

void Slic3r::GUI::ObjectList::delete_volume_from_list	(	const size_t	obj_idx,
		const size_t	vol_idx )

{
    select_item([this, obj_idx, vol_idx]() { return m_objects_model->Delete(m_objects_model->GetItemByVolumeId(obj_idx, vol_idx)); });
}

References m_objects_model, and select_item().

Referenced by delete_from_model_and_list().

Here is the call graph for this function:

Here is the caller graph for this function:

dispatch_shortcut()

bool Slic3r::GUI::ObjectList::dispatch_shortcut

(

Shortcut

shortcut

)

{
    switch (shortcut) {
    case Shortcut::DeleteSelected:  remove(); break;
    case Shortcut::SelectAll:       select_item_all_children(); break;
    case Shortcut::Copy:            copy(); break;
    case Shortcut::Paste:           paste(); break;
    case Shortcut::Cut:             cut(); break;
    case Shortcut::Undo:            undo(); break;
    case Shortcut::Redo:            redo(); break;
    case Shortcut::CloneSelected:   clone(); break;
    case Shortcut::AddInstance:     increase_instances(); break;
    case Shortcut::RemoveInstance:  decrease_instances(); break;
    case Shortcut::TogglePrintable: toggle_printable_state(); break;
    case Shortcut::ToggleAutoDrop:  toggle_auto_drop(); break;
    default: return false;
    }
    return true;
}

References Slic3r::GUI::AddInstance, clone(), Slic3r::GUI::CloneSelected, Slic3r::GUI::Copy, copy(), Slic3r::GUI::Cut, cut(), decrease_instances(), Slic3r::GUI::DeleteSelected, increase_instances(), Slic3r::GUI::Paste, paste(), Slic3r::GUI::Redo, redo(), remove(), Slic3r::GUI::RemoveInstance, select_item_all_children(), Slic3r::GUI::SelectAll, toggle_auto_drop(), toggle_printable_state(), Slic3r::GUI::ToggleAutoDrop, Slic3r::GUI::TogglePrintable, Slic3r::GUI::Undo, and undo().

Referenced by ObjectList(), and key_event().

Here is the call graph for this function:

Here is the caller graph for this function:

edit_layer_range() [1/2]

bool Slic3r::GUI::ObjectList::edit_layer_range	(	const t_layer_height_range &	range,
		const t_layer_height_range &	new_range,
		bool	suppress_ui_update = false )

{
    // Use m_selected_object_id instead of get_selected_obj_idx()
    // because of get_selected_obj_idx() return obj_idx for currently selected item.
    // But edit_layer_range(...) function can be called, when Selection in ObjectList could be changed
    const int obj_idx = m_selected_object_id;
    if (obj_idx < 0) return false;
 
    // BBS: remove snapeshot name "Edit Height Range"
    take_snapshot("");
 
    const ItemType sel_type = m_objects_model->GetItemType(GetSelection());
 
    auto& ranges = object(obj_idx)->layer_config_ranges;
 
    {
        ModelConfig config = std::move(ranges[range]);
        ranges.erase(range);
        ranges[new_range] = std::move(config);
    }
 
    changed_object(obj_idx);
 
    wxDataViewItem root_item = m_objects_model->GetLayerRootItem(m_objects_model->GetItemById(obj_idx));
    // To avoid update selection after deleting of a selected item (under GTK)
    // set m_prevent_list_events to true
    m_prevent_list_events = true;
    m_objects_model->DeleteChildren(root_item);
 
    if (root_item.IsOk()) {
        // create Layer item(s) according to the layer_config_ranges
        for (const auto& r : ranges)
            add_layer_item(r.first, root_item);
    }
 
    // if this function was invoked from wxEVT_CHANGE_SELECTION selected item could be other than itLayer or itLayerRoot
    if (!dont_update_ui && (sel_type & (itLayer | itLayerRoot)))
        select_item(sel_type&itLayer ? m_objects_model->GetItemByLayerRange(obj_idx, new_range) : root_item);
 
    Expand(root_item);
 
    m_prevent_list_events = false;
    return true;
}

References add_layer_item(), changed_object(), config(), Slic3r::GUI::itLayer, Slic3r::GUI::itLayerRoot, Slic3r::ModelObject::layer_config_ranges, m_objects_model, m_prevent_list_events, m_selected_object_id, object(), Slic3r::range(), select_item(), and Slic3r::GUI::take_snapshot().

Here is the call graph for this function:

edit_layer_range() [2/2]

bool Slic3r::GUI::ObjectList::edit_layer_range	(	const t_layer_height_range &	range,
		coordf_t	layer_height )

{
    // Use m_selected_object_id instead of get_selected_obj_idx()
    // because of get_selected_obj_idx() return obj_idx for currently selected item.
    // But edit_layer_range(...) function can be called, when Selection in ObjectList could be changed
    const int obj_idx = m_selected_object_id ;
    if (obj_idx < 0)
        return false;
 
    ModelConfig* config = &object(obj_idx)->layer_config_ranges[range];
    if (fabs(layer_height - config->opt_float("layer_height")) < EPSILON)
        return false;
 
    const int extruder_idx = config->opt_int("extruder");
 
    if (layer_height >= get_min_layer_height(extruder_idx) &&
        layer_height <= get_max_layer_height(extruder_idx))
    {
        config->set_key_value("layer_height", new ConfigOptionFloat(layer_height));
        changed_object(obj_idx);
        return true;
    }
 
    return false;
}

References changed_object(), config(), Slic3r::ConfigOptionFloat, EPSILON, Slic3r::GUI::get_max_layer_height(), Slic3r::GUI::get_min_layer_height(), Slic3r::ModelObject::layer_config_ranges, Slic3r::GUI::layer_height, m_selected_object_id, object(), and Slic3r::range().

Here is the call graph for this function:

enable_layers_editing()

void Slic3r::GUI::ObjectList::enable_layers_editing

(

)

{
    wxDataViewItemArray sels;
    GetSelections(sels);
    if (sels.IsEmpty())
        return;
 
    wxDataViewItem frst_item = sels[0];
 
    ItemType type = m_objects_model->GetItemType(frst_item);
    if (!(type & itObject))
        return;
    //take_snapshot("");
 
    auto view3d = wxGetApp().plater()->get_view3D_canvas3D();
    if (view3d != nullptr && m_objects_model->IsVariableHeight(frst_item)){
        view3d->enable_layers_editing(true);
    }
}

References Slic3r::GUI::itObject, and m_objects_model.

Referenced by list_manipulation().

Here is the caller graph for this function:

ensure_current_item_visible()

void Slic3r::GUI::ObjectList::ensure_current_item_visible ( )

inlineprivate

    {
        if (const auto &item = this->GetCurrentItem())
            this->EnsureVisible(item);
    }

Referenced by ObjectList(), selected_object(), and update_selections().

Here is the caller graph for this function:

extruder_editing()

void Slic3r::GUI::ObjectList::extruder_editing

(

)

{
    wxDataViewItem item = GetSelection();
    if (!item || !(m_objects_model->GetItemType(item) & (itVolume | itObject)))
        return;
 
    const int column_width = GetColumn(colFilament)->GetWidth() + wxSystemSettings::GetMetric(wxSYS_VSCROLL_X) + 5;
 
    wxPoint pos = this->get_mouse_position_in_control();
    wxSize size = wxSize(column_width, -1);
    pos.x = GetColumn(colName)->GetWidth() + GetColumn(colPrint)->GetWidth() + GetColumn(colHeight)->GetWidth() + 5;
    pos.y -= GetTextExtent("m").y;
 
    apply_extruder_selector(&m_extruder_editor, this, "1", pos, size);
 
    m_extruder_editor->SetSelection(m_objects_model->GetExtruderNumber(item));
    m_extruder_editor->Show();
 
    auto set_extruder = [this]()
    {
        wxDataViewItem item = GetSelection();
        if (!item) return;
 
        const int selection = m_extruder_editor->GetSelection();
        if (selection >= 0)
            m_objects_model->SetExtruder(m_extruder_editor->GetString(selection), item);
 
        m_extruder_editor->Hide();
        update_filament_in_config(item);
    };
 
    // to avoid event propagation to other sidebar items
    m_extruder_editor->Bind(wxEVT_COMBOBOX, [set_extruder](wxCommandEvent& evt)
    {
        set_extruder();
        evt.StopPropagation();
    });
}

References apply_extruder_selector(), Slic3r::GUI::colFilament, Slic3r::GUI::colHeight, Slic3r::GUI::colName, Slic3r::GUI::colPrint, get_mouse_position_in_control(), Slic3r::GUI::itObject, Slic3r::GUI::itVolume, m_extruder_editor, m_objects_model, and update_filament_in_config().

Referenced by list_manipulation().

Here is the call graph for this function:

Here is the caller graph for this function:

fix_all_through_cgal()

void Slic3r::GUI::ObjectList::fix_all_through_cgal

(

bool

all_plates

)

{
    std::vector<int> obj_idxs;
    if (all_plates) {
        for (int obj_idx = 0; obj_idx < int(m_objects->size()); ++obj_idx)
            obj_idxs.push_back(obj_idx);
    } else {
        for (const ModelObject *mo : wxGetApp().plater()->get_partplate_list().get_selected_plate()->get_objects_on_this_plate())
            obj_idxs.push_back(int(std::find(m_objects->begin(), m_objects->end(), mo) - m_objects->begin()));
        std::sort(obj_idxs.begin(), obj_idxs.end());
        obj_idxs.erase(std::unique(obj_idxs.begin(), obj_idxs.end()), obj_idxs.end());
    }
    fix_through_cgal(obj_idxs, {});
}

References fix_through_cgal(), m_objects, and Slic3r::GUI::plater().

Here is the call graph for this function:

fix_cut_selection() [1/2]

void Slic3r::GUI::ObjectList::fix_cut_selection

(

)

{
    wxDataViewItemArray sels;
    GetSelections(sels);
    if (fix_cut_selection(sels)) {
        m_prevent_list_events = true;
 
        // If some part is selected, unselect all items except of selected parts of the current object
        UnselectAll();
        SetSelections(sels);
 
        m_prevent_list_events = false;
    }
}

References fix_cut_selection(), and m_prevent_list_events.

Referenced by fix_cut_selection(), selection_changed(), and update_selections().

Here is the call graph for this function:

Here is the caller graph for this function:

fix_cut_selection() [2/2]

bool Slic3r::GUI::ObjectList::fix_cut_selection

(

wxDataViewItemArray &

sels

)

{
    if (wxGetApp().plater()->canvas3D()->get_gizmos_manager().get_current_type() == GLGizmosManager::Scale) {
        for (const auto &item : sels) {
            if (m_objects_model->GetItemType(item) & (itInstance | itObject) ||
                (m_objects_model->GetItemType(item) & itSettings && m_objects_model->GetItemType(m_objects_model->GetParent(item)) & itObject)) {
                bool is_instance_selection = m_objects_model->GetItemType(item) & itInstance;
 
                int object_idx = m_objects_model->GetObjectIdByItem(item);
                int inst_idx   = is_instance_selection ? m_objects_model->GetInstanceIdByItem(item) : 0;
 
                if (auto obj = object(object_idx); obj->is_cut()) {
                    sels.Clear();
 
                    auto cut_id = obj->cut_id;
 
                    int objects_cnt = int((*m_objects).size());
                    for (int obj_idx = 0; obj_idx < objects_cnt; ++obj_idx) {
                        auto object = (*m_objects)[obj_idx];
                        if (object->is_cut() && object->cut_id.has_same_id(cut_id))
                            sels.Add(is_instance_selection ? m_objects_model->GetItemByInstanceId(obj_idx, inst_idx) : m_objects_model->GetItemById(obj_idx));
                    }
                    return true;
                }
            }
        }
    }
    return false;
}

References Slic3r::GUI::itInstance, Slic3r::GUI::itObject, Slic3r::GUI::itSettings, m_objects_model, object(), Slic3r::GUI::plater(), and Slic3r::GUI::GLGizmosManager::Scale.

Here is the call graph for this function:

fix_multiselection_conflicts()

void Slic3r::GUI::ObjectList::fix_multiselection_conflicts

(

)

{
    if (GetSelectedItemsCount() <= 1) {
        update_selection_mode();
        return;
    }
 
    wxString msg_string;
    if (!check_last_selection(msg_string))
        return;
 
    m_prevent_list_events = true;
 
    wxDataViewItemArray sels;
    GetSelections(sels);
 
    if (m_selection_mode & (smVolume|smLayer))
    {
        // identify correct parent of the initial selected item
        const wxDataViewItem& parent = m_objects_model->GetParent(m_last_selected_item == sels.front() ? sels.back() : sels.front());
 
        sels.clear();
        wxDataViewItemArray children; // selected volumes from current parent
        m_objects_model->GetChildren(parent, children);
 
        const ItemType item_type = m_selection_mode & smVolume ? itVolume : itLayer;
 
        for (const auto& child : children)
            if (IsSelected(child) && m_objects_model->GetItemType(child) & item_type)
                sels.Add(child);
 
        // If some part is selected, unselect all items except of selected parts of the current object
        UnselectAll();
        SetSelections(sels);
    }
    else
    {
        for (const auto& item : sels)
        {
            if (!IsSelected(item)) // if this item is unselected now (from previous actions)
                continue;
 
            if (m_objects_model->GetItemType(item) & itSettings) {
                Unselect(item);
                continue;
            }
 
            const wxDataViewItem& parent = m_objects_model->GetParent(item);
            if (parent != wxDataViewItem(nullptr) && IsSelected(parent))
                Unselect(parent);
            else
            {
                wxDataViewItemArray unsels;
                m_objects_model->GetAllChildren(item, unsels);
                for (const auto& unsel_item : unsels)
                    Unselect(unsel_item);
            }
 
            if (m_objects_model->GetItemType(item) & itVolume)
                Unselect(item);
 
            m_selection_mode = smInstance;
        }
    }
 
    if (!msg_string.IsEmpty())
        show_info(this, msg_string, _(L("Info")));
 
    if (!IsSelected(m_last_selected_item))
        m_last_selected_item = wxDataViewItem(nullptr);
 
    m_prevent_list_events = false;
}

References _, check_last_selection(), Slic3r::GUI::itLayer, Slic3r::GUI::itSettings, Slic3r::GUI::itVolume, L, m_last_selected_item, m_objects_model, m_prevent_list_events, m_selection_mode, Slic3r::GUI::show_info(), smInstance, smLayer, smVolume, and update_selection_mode().

Referenced by selection_changed().

Here is the call graph for this function:

Here is the caller graph for this function:

fix_through_cgal() [1/2]

void Slic3r::GUI::ObjectList::fix_through_cgal

(

)

{
    std::vector<int> obj_idxs, vol_idxs;
    get_selection_indexes(obj_idxs, vol_idxs);
    fix_through_cgal(obj_idxs, vol_idxs);
}

References fix_through_cgal(), and get_selection_indexes().

Referenced by fix_all_through_cgal(), fix_through_cgal(), and list_manipulation().

Here is the call graph for this function:

Here is the caller graph for this function:

fix_through_cgal() [2/2]

void Slic3r::GUI::ObjectList::fix_through_cgal	(	const std::vector< int > &	obj_idxs,
		const std::vector< int > &	vol_idxs )

{
    // Do not fix anything when a gizmo is open. There might be issues with updates
    // and what is worse, the snapshot time would refer to the internal stack.
    if (obj_idxs.empty() || !wxGetApp().plater()->get_view3D_canvas3D()->get_gizmos_manager().check_gizmos_closed_except(GLGizmosManager::Undefined))
        return;
 
    //          model_name
    std::vector<std::string>                           succes_models;
    //                   model_name     failing reason
    std::vector<std::pair<std::string, std::string>>   failed_models;
    size_t                                             unchanged_models = 0;
    bool                                               painting_removed = false;
 
    std::vector<std::string> model_names;
 
    if (vol_idxs.empty()) {
        for (int obj_idx : obj_idxs)
            if (object(obj_idx))
                model_names.push_back(object(obj_idx)->name);
    }
    else {
        ModelObject* obj = object(obj_idxs.front());
        if (obj) {
            for (int vol_idx : vol_idxs)
                model_names.push_back(obj->volumes[vol_idx]->name);
        }
    }
 
    auto plater = wxGetApp().plater();
    const bool keep_painting = GUI::wxGetApp().app_config->get_bool("keep_painting");
 
    auto fix_and_update_progress = [&](const int obj_idx, const int vol_idx, int model_idx, ProgressDialog& progress_dlg)
    {
        ModelObject *mo = object(obj_idx);
        if (!mo)
            return false;
 
        const std::string& model_name = model_names[model_idx];
        wxString msg = _L("Repairing model object");
        if (model_names.size() == 1)
            msg += ": " + from_u8(model_name) + "\n";
        else if (model_names.size() > 10)
            msg += ": " + from_u8(model_name) + wxString::Format(" (%d/%d)", model_idx + 1, int(model_names.size())) + "\n";
        else {
            msg += ":\n";
            for (int i = 0; i < int(model_names.size()); ++i)
                msg += (i == model_idx ? " > " : "   ") + from_u8(model_names[i]) + "\n";
            msg += "\n";
        }
 
        auto count_painted = [mo]() { return std::count_if(mo->volumes.begin(), mo->volumes.end(), [](const ModelVolume *mv) { return mv->is_any_painted(); }); };
        const auto  painted_before = count_painted();
        std::string res;
        bool        modified = false;
        if (!fix_model_with_cgal_gui(*mo, vol_idx, progress_dlg, msg, res, keep_painting, &modified))
            return false;
 
        if (modified) {
            painting_removed = painting_removed || count_painted() < painted_before;
            mo->ensure_on_bed();
            plater->changed_mesh(obj_idx);
            plater->get_partplate_list().notify_instance_update(obj_idx, 0);
            plater->sidebar().obj_list()->update_plate_values_for_items();
            update_item_error_icon(obj_idx, vol_idx);
            update_info_items(obj_idx);
        }
 
        if (!res.empty())
            failed_models.push_back({ model_name, res });
        else if (modified)
            succes_models.push_back(model_name);
        else
            ++unchanged_models;
        return true;
    };
 
    Plater::TakeSnapshot snapshot(plater, _u8L("Repairing model object"));
 
    // Open a progress dialog.
    ProgressDialog progress_dlg(_L("Repairing model object"), "", 100, find_toplevel_parent(plater),
                                    wxPD_AUTO_HIDE | wxPD_APP_MODAL | wxPD_CAN_ABORT, true);
    int model_idx{ 0 };
    if (vol_idxs.empty()) {
        int vol_idx{ -1 };
        for (int obj_idx : obj_idxs) {
            if (!fix_and_update_progress(obj_idx, vol_idx, model_idx, progress_dlg))
                break;
            model_idx++;
        }
    }
    else {
        int obj_idx{ obj_idxs.front() };
        for (int vol_idx : vol_idxs) {
            if (!fix_and_update_progress(obj_idx, vol_idx, model_idx, progress_dlg))
                break;
            model_idx++;
        }
    }
    // Close the progress dialog
    progress_dlg.Update(100, "");
 
    if (painting_removed)
        plater->notify_painting_removed();
 
    // Show info notification
    std::vector<wxString> blocks;
    wxString bullet_suf = "\n   - ";
    if (!succes_models.empty()) {
        wxString block = _L_PLURAL("The following model object has been repaired", "The following model objects have been repaired", succes_models.size()) + ":";
        for (auto& model : succes_models)
            block += bullet_suf + from_u8(model);
        blocks.push_back(block);
    }
    if (!failed_models.empty()) {
        wxString block = _L_PLURAL("Failed to repair the following model object", "Failed to repair the following model objects", failed_models.size()) + ":";
        for (auto& model : failed_models)
            block += bullet_suf + from_u8(model.first) + ": " + _(model.second);
        blocks.push_back(block);
    }
    if (unchanged_models > 0)
        blocks.push_back(format_wxstr(_L_PLURAL("%1$d model object needed no repair.", "%1$d model objects needed no repair.", unchanged_models), unchanged_models));
    wxString msg;
    for (const wxString &block : blocks)
        msg += (msg.IsEmpty() ? "" : "\n\n") + block;
    if (msg.IsEmpty())
        msg = _L("Repairing was canceled");
    plater->get_notification_manager()->push_notification(NotificationType::CgalFinished, NotificationManager::NotificationLevel::PrintInfoShortNotificationLevel, into_u8(msg));
}

References _, _L, _L_PLURAL, _u8L, Slic3r::GUI::CgalFinished, Slic3r::ModelObject::ensure_on_bed(), Slic3r::GUI::find_toplevel_parent(), Slic3r::fix_model_with_cgal_gui(), Slic3r::GUI::format_wxstr(), Slic3r::GUI::from_u8(), Slic3r::GUI::into_u8(), object(), Slic3r::GUI::plater(), Slic3r::GUI::NotificationManager::PrintInfoShortNotificationLevel, Slic3r::GUI::GLGizmosManager::Undefined, Slic3r::GUI::ProgressDialog::Update(), update_info_items(), update_item_error_icon(), and Slic3r::ModelObject::volumes.

Here is the call graph for this function:

get_default_layer_config()

DynamicPrintConfig Slic3r::GUI::ObjectList::get_default_layer_config

(

const int

obj_idx

)

{
    DynamicPrintConfig config;
    coordf_t layer_height = object(obj_idx)->config.has("layer_height") ?
                            object(obj_idx)->config.opt_float("layer_height") :
                            wxGetApp().preset_bundle->prints.get_edited_preset().config.opt_float("layer_height");
    config.set_key_value("layer_height",new ConfigOptionFloat(layer_height));
    // BBS
    int extruder = object(obj_idx)->config.has("extruder") ?
        object(obj_idx)->config.opt_int("extruder") :
        wxGetApp().preset_bundle->prints.get_edited_preset().config.opt_float("extruder");
    config.set_key_value("extruder",    new ConfigOptionInt(0));
 
    return config;
}

References config(), Slic3r::ModelObject::config, Slic3r::ConfigOptionFloat, Slic3r::ModelConfig::has(), Slic3r::GUI::layer_height, object(), Slic3r::ModelConfig::opt_float(), and Slic3r::ModelConfig::opt_int().

Referenced by add_layer_range_after_current(), and layers_editing().

Here is the call graph for this function:

Here is the caller graph for this function:

get_item_config()

ModelConfig & Slic3r::GUI::ObjectList::get_item_config

(

const wxDataViewItem &

item

)

const

{
    static ModelConfig s_empty_config;
 
    assert(item);
    const ItemType type = m_objects_model->GetItemType(item);
 
    if (type & itPlate)
        return s_empty_config;
 
    const int obj_idx = m_objects_model->GetObjectIdByItem(item);
    const int vol_idx = type & itVolume ? m_objects_model->GetVolumeIdByItem(item) : -1;
 
    assert(obj_idx >= 0 || ((type & itVolume) && vol_idx >=0));
    return type & itVolume ?(*m_objects)[obj_idx]->volumes[vol_idx]->config :
           type & itLayer  ?(*m_objects)[obj_idx]->layer_config_ranges[m_objects_model->GetLayerRangeByItem(item)] :
                            (*m_objects)[obj_idx]->config;
}

References Slic3r::GUI::itLayer, Slic3r::GUI::itPlate, Slic3r::GUI::itVolume, and m_objects_model.

Referenced by add_category_to_settings_from_frequent(), add_category_to_settings_from_selection(), copy_settings_to_clipboard(), Slic3r::GUI::create_settings_popupmenu(), part_selection_changed(), paste_settings_into_list(), set_extruder_for_selected_items(), update_filament_in_config(), and update_settings_item_and_selection().

Here is the caller graph for this function:

get_mesh_errors_info() [1/2]

MeshErrorsInfo Slic3r::GUI::ObjectList::get_mesh_errors_info	(	const int	obj_idx,
		const int	vol_idx = -1,
		wxString *	sidebar_info = nullptr,
		int *	non_manifold_edges = nullptr ) const

{
    if (obj_idx < 0)
        return { {}, {} }; // hide tooltip
 
    const TriangleMeshStats& stats = vol_idx == -1 ?
        (*m_objects)[obj_idx]->get_object_stl_stats() :
        (*m_objects)[obj_idx]->volumes[vol_idx]->mesh().stats();
 
    if (!stats.repaired() && stats.manifold()) {
        //if (sidebar_info)
        //    *sidebar_info = _L("No errors");
        return { {}, {} }; // hide tooltip
    }
 
    wxString tooltip, auto_repaired_info, remaining_info;
 
    // Create tooltip string, if there are errors
    if (stats.repaired()) {
        const int errors = get_repaired_errors_count(obj_idx, vol_idx);
        auto_repaired_info = format_wxstr(_L_PLURAL("%1$d error repaired", "%1$d errors repaired", errors), errors);
        tooltip += auto_repaired_info + "\n";
    }
    if (!stats.manifold()) {
        remaining_info = format_wxstr(_L_PLURAL("Error: %1$d non-manifold edge.", "Error: %1$d non-manifold edges.", stats.open_edges), stats.open_edges);
 
        tooltip += _L("Remaining errors") + ":\n";
        tooltip += "\t" + format_wxstr(_L_PLURAL("%1$d non-manifold edge", "%1$d non-manifold edges", stats.open_edges), stats.open_edges) + "\n";
    }
 
    if (sidebar_info) {
        *sidebar_info = stats.manifold() ? auto_repaired_info : (remaining_info + (stats.repaired() ? ("\n" + auto_repaired_info) : ""));
    }
 
    if (non_manifold_edges)
        *non_manifold_edges = stats.open_edges;
 
    if (!sidebar_info)
        tooltip += "\n" + _L("Click the icon to repair model object");
 
    return { tooltip, get_warning_icon_name(stats) };
}

References _L, _L_PLURAL, Slic3r::GUI::format_wxstr(), get_repaired_errors_count(), Slic3r::GUI::get_warning_icon_name(), Slic3r::TriangleMeshStats::manifold(), Slic3r::TriangleMeshStats::open_edges, and Slic3r::TriangleMeshStats::repaired().

Referenced by get_mesh_errors_info(), and set_tooltip_for_item().

Here is the call graph for this function:

Here is the caller graph for this function:

get_mesh_errors_info() [2/2]

MeshErrorsInfo Slic3r::GUI::ObjectList::get_mesh_errors_info	(	wxString *	sidebar_info = nullptr,
		int *	non_manifold_edges = nullptr )

{
    wxDataViewItem item = GetSelection();
    if (!item)
        return { "", "" };
 
    int obj_idx, vol_idx;
    get_selected_item_indexes(obj_idx, vol_idx);
 
    if (obj_idx < 0) { // child of ObjectItem is selected
        if (sidebar_info)
            obj_idx = m_objects_model->GetObjectIdByItem(item);
        else
            return { "", "" };
    }
    return get_mesh_errors_info(obj_idx, vol_idx, sidebar_info, non_manifold_edges);
}

References get_mesh_errors_info(), get_selected_item_indexes(), and m_objects_model.

Here is the call graph for this function:

get_mouse_position_in_control()

wxPoint Slic3r::GUI::ObjectList::get_mouse_position_in_control ( ) const

inline

{ return wxGetMousePosition() - this->GetScreenPosition(); }

Referenced by ObjectList(), extruder_editing(), and OnContextMenu().

Here is the caller graph for this function:

get_repaired_errors_count()

int Slic3r::GUI::ObjectList::get_repaired_errors_count	(	const int	obj_idx,
		const int	vol_idx = -1 ) const

{
    return obj_idx >= 0 ? (*m_objects)[obj_idx]->get_repaired_errors_count(vol_idx) : 0;
}

Referenced by get_mesh_errors_info().

Here is the caller graph for this function:

get_selected_item_indexes()

void Slic3r::GUI::ObjectList::get_selected_item_indexes	(	int &	obj_idx,
		int &	vol_idx,
		const wxDataViewItem &	item = wxDataViewItem(0) )

{
    const wxDataViewItem item = input_item == wxDataViewItem(nullptr) ? GetSelection() : input_item;
 
    if (!item)
    {
        obj_idx = vol_idx = -1;
        return;
    }
 
    const ItemType type = m_objects_model->GetItemType(item);
 
    obj_idx =   type & itObject ? m_objects_model->GetIdByItem(item) :
                type & itVolume ? m_objects_model->GetIdByItem(m_objects_model->GetObject(item)) : -1;
 
    vol_idx =   type & itVolume ? m_objects_model->GetVolumeIdByItem(item) : -1;
}

References Slic3r::GUI::itObject, Slic3r::GUI::itVolume, and m_objects_model.

Referenced by get_mesh_errors_info(), list_manipulation(), OnEditingStarted(), and show_context_menu().

Here is the caller graph for this function:

get_selected_layers_range_idx()

int Slic3r::GUI::ObjectList::get_selected_layers_range_idx

(

)

const

{
    const wxDataViewItem& item = GetSelection();
    if (!item)
        return -1;
 
    const ItemType type = m_objects_model->GetItemType(item);
    if (type & itSettings && m_objects_model->GetItemType(m_objects_model->GetParent(item)) != itLayer)
        return -1;
 
    return m_objects_model->GetLayerIdByItem(type & itLayer ? item : m_objects_model->GetParent(item));
}

References Slic3r::GUI::itLayer, Slic3r::GUI::itSettings, and m_objects_model.

Referenced by Slic3r::GUI::Plater::priv::take_snapshot(), and Slic3r::GUI::Plater::priv::undo_redo_to().

Here is the caller graph for this function:

get_selected_model_volume()

ModelVolume * Slic3r::GUI::ObjectList::get_selected_model_volume

(

)

{
    wxDataViewItem item = GetSelection();
    if (!item)
        return nullptr;
    if (m_objects_model->GetItemType(item) != itVolume) {
        if (m_objects_model->GetItemType(m_objects_model->GetParent(item)) == itVolume)
            item = m_objects_model->GetParent(item);
        else
            return nullptr;
    }
 
    const auto vol_idx = m_objects_model->GetVolumeIdByItem(item);
    const auto obj_idx = get_selected_obj_idx();
    if (vol_idx < 0 || obj_idx < 0)
        return nullptr;
 
    return (*m_objects)[obj_idx]->volumes[vol_idx];
}

References get_selected_obj_idx(), Slic3r::GUI::itVolume, m_objects, and m_objects_model.

Referenced by get_selected_volume_type().

Here is the call graph for this function:

Here is the caller graph for this function:

get_selected_obj_idx()

int Slic3r::GUI::ObjectList::get_selected_obj_idx

(

)

const

{
    if (GetSelectedItemsCount() == 1)
        return m_objects_model->GetIdByItem(m_objects_model->GetObject(GetSelection()));
 
    return -1;
}

References m_objects_model.

Referenced by add_layer_range_after_current(), can_add_new_range_after_current(), can_merge_to_single_object(), can_mesh_boolean(), changed_object(), del_layer_range(), get_selected_model_volume(), get_volume_by_item(), is_splittable(), load_generic_subobject(), load_modifier(), split(), and Slic3r::GUI::ObjectLayers::update_layers_list().

Here is the caller graph for this function:

get_selected_volume_type()

ModelVolumeType Slic3r::GUI::ObjectList::get_selected_volume_type

(

)

{
    ModelVolume* volume = get_selected_model_volume();
    if (volume)
        return volume->type();
    return ModelVolumeType::INVALID;
}

References get_selected_model_volume(), Slic3r::INVALID, and Slic3r::ModelVolume::type().

Here is the call graph for this function:

get_selection_indexes()

void Slic3r::GUI::ObjectList::get_selection_indexes	(	std::vector< int > &	obj_idxs,
		std::vector< int > &	vol_idxs )

{
    wxDataViewItemArray sels;
    GetSelections(sels);
    if (sels.IsEmpty())
        return;
 
    if ( m_objects_model->GetItemType(sels[0]) & itVolume ||
        (sels.Count()==1 && m_objects_model->GetItemType(m_objects_model->GetParent(sels[0])) & itVolume) ) {
        for (wxDataViewItem item : sels) {
            obj_idxs.emplace_back(m_objects_model->GetIdByItem(m_objects_model->GetObject(item)));
 
            if (sels.Count() == 1 && m_objects_model->GetItemType(m_objects_model->GetParent(item)) & itVolume)
                item = m_objects_model->GetParent(item);
 
            assert(m_objects_model->GetItemType(item) & itVolume);
            vol_idxs.emplace_back(m_objects_model->GetVolumeIdByItem(item));
        }
    }
    else {
        for (wxDataViewItem item : sels) {
            const ItemType type = m_objects_model->GetItemType(item);
            obj_idxs.emplace_back(type & itObject ? m_objects_model->GetIdByItem(item) :
                                  m_objects_model->GetIdByItem(m_objects_model->GetObject(item)));
        }
    }
 
    std::sort(obj_idxs.begin(), obj_idxs.end(), std::less<int>());
    obj_idxs.erase(std::unique(obj_idxs.begin(), obj_idxs.end()), obj_idxs.end());
}

References Slic3r::GUI::itObject, Slic3r::GUI::itVolume, and m_objects_model.

Referenced by boolean(), fix_through_cgal(), and smooth_mesh().

Here is the caller graph for this function:

get_volume_by_item()

bool Slic3r::GUI::ObjectList::get_volume_by_item	(	const wxDataViewItem &	item,
		ModelVolume *&	volume )

{
    auto obj_idx = get_selected_obj_idx();
    if (!item || obj_idx < 0)
        return false;
    const auto volume_id = m_objects_model->GetVolumeIdByItem(item);
    const bool split_part = m_objects_model->GetItemType(item) == itVolume;
 
    // object is selected
    if (volume_id < 0) {
        if ( split_part || (*m_objects)[obj_idx]->volumes.size() > 1 )
            return false;
        volume = (*m_objects)[obj_idx]->volumes[0];
    }
    // volume is selected
    else
        volume = (*m_objects)[obj_idx]->volumes[volume_id];
 
    return true;
}

References get_selected_obj_idx(), Slic3r::GUI::itVolume, m_objects, and m_objects_model.

Referenced by is_splittable(), and split().

Here is the call graph for this function:

Here is the caller graph for this function:

GetModel()

ObjectDataViewModel * Slic3r::GUI::ObjectList::GetModel ( ) const

inline

{ return m_objects_model; }

References m_objects_model.

Referenced by Slic3r::GUI::MenuFactory::append_menu_item_printable(), Slic3r::GUI::MenuFactory::append_menu_item_set_printable(), and Slic3r::GUI::ObjectLayers::update_layers_list().

Here is the caller graph for this function:

has_selected_cut_object()

bool Slic3r::GUI::ObjectList::has_selected_cut_object

(

)

const

{
    wxDataViewItemArray sels;
    GetSelections(sels);
    if (sels.IsEmpty())
        return false;
 
    for (wxDataViewItem item : sels) {
        const int obj_idx = m_objects_model->GetObjectIdByItem(item);
        // ys_FIXME: The obj_idx<size condition is a workaround for https://github.com/prusa3d/PrusaSlicer/issues/11186,
        // but not the correct fix. The deleted item probably should not be in sels in the first place.
        if (obj_idx >= 0 && obj_idx < int(m_objects->size()) && object(obj_idx)->is_cut())
            return true;
    }
 
    return false;
}

References m_objects, and m_objects_model.

Referenced by can_merge_to_multipart_object().

Here is the caller graph for this function:

increase_instances()

void Slic3r::GUI::ObjectList::increase_instances

(

)

{
    wxGetApp().plater()->increase_instances(1);
}

Referenced by dispatch_shortcut().

Here is the caller graph for this function:

increase_object_instances()

void Slic3r::GUI::ObjectList::increase_object_instances	(	const size_t	obj_idx,
		const size_t	num )

{
    select_item([this, obj_idx, num]() { return m_objects_model->AddInstanceChild(m_objects_model->GetItemById(obj_idx), num); });
    selection_changed();
}

References m_objects_model, select_item(), and selection_changed().

Referenced by Slic3r::GUI::Plater::increase_instances().

Here is the call graph for this function:

Here is the caller graph for this function:

init()

void Slic3r::GUI::ObjectList::init

(

)

{
    m_objects_model->Init();
    m_objects = &wxGetApp().model().objects;
}

References m_objects, and m_objects_model.

instances_to_separated_object()

void Slic3r::GUI::ObjectList::instances_to_separated_object	(	const int	obj_idx,
		const std::set< int > &	inst_idx )

{
    if ((*m_objects)[obj_idx]->instances.size() == inst_idxs.size())
    {
        instances_to_separated_objects(obj_idx);
        return;
    }
 
    // create new object from selected instance
    ModelObject* model_object = (*m_objects)[obj_idx]->get_model()->add_object(*(*m_objects)[obj_idx]);
    for (int inst_idx = int(model_object->instances.size()) - 1; inst_idx >= 0; inst_idx--)
    {
        if (find(inst_idxs.begin(), inst_idxs.end(), inst_idx) != inst_idxs.end())
            continue;
        model_object->delete_instance(inst_idx);
    }
 
    // Add new object to the object_list
    const size_t new_obj_indx = static_cast<size_t>(m_objects->size() - 1);
    add_object_to_list(new_obj_indx);
 
    for (std::set<int>::const_reverse_iterator it = inst_idxs.rbegin(); it != inst_idxs.rend(); ++it)
    {
        // delete selected instance from the object
        del_subobject_from_object(obj_idx, *it, itInstance);
        delete_instance_from_list(obj_idx, *it);
    }
 
    // update printable state for new volumes on canvas3D
    wxGetApp().plater()->get_view3D_canvas3D()->update_instance_printable_state_for_object(new_obj_indx);
    update_info_items(new_obj_indx);
}

References Slic3r::Model::add_object(), add_object_to_list(), del_subobject_from_object(), Slic3r::ModelObject::delete_instance(), delete_instance_from_list(), Slic3r::ModelObject::get_model(), Slic3r::ModelObject::instances, instances_to_separated_objects(), Slic3r::GUI::itInstance, m_objects, and update_info_items().

Referenced by merge(), and split_instances().

Here is the call graph for this function:

Here is the caller graph for this function:

instances_to_separated_objects()

void Slic3r::GUI::ObjectList::instances_to_separated_objects

(

const int

obj_idx

)

{
    const int inst_cnt = (*m_objects)[obj_idx]->instances.size();
 
    std::vector<size_t> object_idxs;
 
    for (int i = inst_cnt-1; i > 0 ; i--)
    {
        // create new object from initial
        ModelObject* object = (*m_objects)[obj_idx]->get_model()->add_object(*(*m_objects)[obj_idx]);
        for (int inst_idx = object->instances.size() - 1; inst_idx >= 0; inst_idx--)
        {
            if (inst_idx == i)
                continue;
            // delete unnecessary instances
            object->delete_instance(inst_idx);
        }
 
        // Add new object to the object_list
        const size_t new_obj_indx = static_cast<size_t>(m_objects->size() - 1);
        add_object_to_list(new_obj_indx);
        object_idxs.push_back(new_obj_indx);
 
        // delete current instance from the initial object
        del_subobject_from_object(obj_idx, i, itInstance);
        delete_instance_from_list(obj_idx, i);
    }
 
    // update printable state for new volumes on canvas3D
    wxGetApp().plater()->get_view3D_canvas3D()->update_instance_printable_state_for_objects(object_idxs);
    for (size_t object : object_idxs)
        update_info_items(object);
}

References Slic3r::Model::add_object(), add_object_to_list(), del_subobject_from_object(), delete_instance_from_list(), Slic3r::ModelObject::get_model(), Slic3r::GUI::itInstance, m_objects, object(), and update_info_items().

Referenced by instances_to_separated_object(), merge(), and split_instances().

Here is the call graph for this function:

Here is the caller graph for this function:

invalidate_cut_info_for_object()

void Slic3r::GUI::ObjectList::invalidate_cut_info_for_object

(

int

obj_idx

)

{
    ModelObject* init_obj = object(obj_idx);
    if (!init_obj->is_cut())
        return;
 
    take_snapshot(_u8L("Invalidate cut info"));
 
    const CutObjectBase cut_id = init_obj->cut_id;
    // invalidate cut for related objects (which have the same cut_id)
    for (size_t idx = 0; idx < m_objects->size(); idx++)
        if (ModelObject* obj = object(int(idx)); obj->cut_id.is_equal(cut_id)) {
            obj->invalidate_cut();
            update_info_items(idx);
            add_volumes_to_object_in_list(idx);
        }
 
    update_lock_icons_for_model();
}

References _u8L, add_volumes_to_object_in_list(), Slic3r::ModelObject::cut_id, Slic3r::ModelObject::is_cut(), Slic3r::CutObjectBase::is_equal(), m_objects, object(), Slic3r::GUI::take_snapshot(), update_info_items(), and update_lock_icons_for_model().

Referenced by invalidate_cut_info_for_selection().

Here is the call graph for this function:

Here is the caller graph for this function:

invalidate_cut_info_for_selection()

void Slic3r::GUI::ObjectList::invalidate_cut_info_for_selection

(

)

{
    const wxDataViewItem item = GetSelection();
    if (item) {
        const int obj_idx = m_objects_model->GetObjectIdByItem(item);
        if (obj_idx >= 0)
            invalidate_cut_info_for_object(size_t(obj_idx));
    }
}

References invalidate_cut_info_for_object(), and m_objects_model.

Referenced by del_from_cut_object().

Here is the call graph for this function:

Here is the caller graph for this function:

is_connectors_item_selected() [1/2]

bool Slic3r::GUI::ObjectList::is_connectors_item_selected

(

)

const

{
    const wxDataViewItem &item = GetSelection();
    if (item)
        return m_objects_model->GetItemType(item) == itInfo && m_objects_model->GetInfoItemType(item) == InfoItemType::CutConnectors;
 
    return false;
}

References Slic3r::GUI::CutConnectors, Slic3r::GUI::itInfo, and m_objects_model.

Referenced by set_volume_type(), and update_selections().

Here is the caller graph for this function:

is_connectors_item_selected() [2/2]

bool Slic3r::GUI::ObjectList::is_connectors_item_selected

(

const wxDataViewItemArray &

sels

)

const

{
    for (auto item : sels)
        if (m_objects_model->GetItemType(item) == itInfo && m_objects_model->GetInfoItemType(item) == InfoItemType::CutConnectors)
            return true;
 
    return false;
}

References Slic3r::GUI::CutConnectors, Slic3r::GUI::itInfo, and m_objects_model.

is_instance_or_object_selected()

bool Slic3r::GUI::ObjectList::is_instance_or_object_selected

(

)

{
    const Selection& selection = scene_selection();
    return selection.is_single_full_instance() || selection.is_single_full_object();
}

References Slic3r::GUI::Selection::is_single_full_instance(), Slic3r::GUI::Selection::is_single_full_object(), and Slic3r::GUI::scene_selection().

Here is the call graph for this function:

is_selected()

bool Slic3r::GUI::ObjectList::is_selected

(

const ItemType

type

)

const

{
    const wxDataViewItem& item = GetSelection();
    if (item)
        return m_objects_model->GetItemType(item) == type;
 
    return false;
}

References m_objects_model.

Referenced by Slic3r::GUI::Plater::priv::take_snapshot(), Slic3r::GUI::Plater::priv::undo_redo_to(), and update_selections().

Here is the caller graph for this function:

is_splittable()

bool Slic3r::GUI::ObjectList::is_splittable

(

bool

to_objects

)

{
    const wxDataViewItem item = GetSelection();
    if (!item) return false;
 
    if (to_objects)
    {
        ItemType type = m_objects_model->GetItemType(item);
        if (type == itVolume)
            return false;
        if (type == itObject || m_objects_model->GetItemType(m_objects_model->GetParent(item)) == itObject) {
            auto obj_idx = get_selected_obj_idx();
            if (obj_idx < 0)
                return false;
            if ((*m_objects)[obj_idx]->volumes.size() > 1)
                return true;
            return (*m_objects)[obj_idx]->volumes[0]->is_splittable();
        }
        return false;
    }
 
    ModelVolume* volume;
    if (!get_volume_by_item(item, volume) || !volume)
        return false;
 
    return volume->is_splittable();
}

References get_selected_obj_idx(), get_volume_by_item(), Slic3r::ModelVolume::is_splittable(), Slic3r::GUI::itObject, Slic3r::GUI::itVolume, m_objects, and m_objects_model.

Referenced by can_mesh_boolean().

Here is the call graph for this function:

Here is the caller graph for this function:

ItemValueChanged()

void Slic3r::GUI::ObjectList::ItemValueChanged ( wxDataViewEvent & event )

private

{
    if (event.GetColumn() == colName)
        update_name_in_model(event.GetItem());
    else if (event.GetColumn() == colFilament) {
        wxDataViewItem item = event.GetItem();
        if (m_objects_model->GetItemType(item) == itObject)
            m_objects_model->UpdateVolumesExtruderBitmap(item, true);
        update_filament_in_config(item);
    }
}

References Slic3r::GUI::colFilament, Slic3r::GUI::colName, Slic3r::GUI::itObject, m_objects_model, update_filament_in_config(), and update_name_in_model().

Referenced by ObjectList().

Here is the call graph for this function:

Here is the caller graph for this function:

key_event()

void Slic3r::GUI::ObjectList::key_event

(

wxKeyEvent &

event

)

{
    const std::optional<Shortcut> shortcut = wxGetApp().shortcuts().lookup(ShortcutContext::ObjectList, KeyChord::from_event(event));
    if (shortcut.has_value() && dispatch_shortcut(*shortcut))
        return;
    if (filaments_count() > 1) {
        std::vector<wxChar> numbers = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' };
        wxChar key_char = event.GetUnicodeKey();
        if (std::find(numbers.begin(), numbers.end(), key_char) != numbers.end()) {
            long extruder_number;
            if (wxNumberFormatter::FromString(wxString(key_char), &extruder_number) &&
                filaments_count() >= extruder_number)
                set_extruder_for_selected_items(int(extruder_number));
        }
        else
            event.Skip();
    }
    else
        event.Skip();
}

References dispatch_shortcut(), Slic3r::GUI::filaments_count(), Slic3r::GUI::KeyChord::from_event(), Slic3r::GUI::ObjectList, and set_extruder_for_selected_items().

Referenced by ObjectList().

Here is the call graph for this function:

Here is the caller graph for this function:

last_volume_is_deleted()

void Slic3r::GUI::ObjectList::last_volume_is_deleted

(

const int

obj_idx

)

{
    // BBS: object (obj_idx calc in obj list) is already removed from m_objects in Plater::priv::remove().
#if 0
    if (obj_idx < 0 || size_t(obj_idx) >= m_objects->size() || (*m_objects)[obj_idx]->volumes.size() != 1)
        return;
 
    auto volume = (*m_objects)[obj_idx]->volumes.front();
 
    // clear volume's config values
    volume->config.reset();
 
    // set a default extruder value, since user can't add it manually
    // BBS
    volume->config.set_key_value("extruder", new ConfigOptionInt(1));
#endif
}

References Slic3r::ModelVolume::config, m_objects, Slic3r::ModelConfig::reset(), and Slic3r::ModelConfig::set_key_value().

Here is the call graph for this function:

layers_editing()

void Slic3r::GUI::ObjectList::layers_editing

(

)

{
    // Height ranges give each range its own layer height, varying the mixed sub-layer heights just
    // like an adaptive profile, so this raises the same warning as variable layer height and shares
    // its do-not-show-again flag.
    const auto& print_config = wxGetApp().preset_bundle->prints.get_edited_preset().config;
    if (print_config.opt_bool("enable_mixed_color_sublayer")) {
        if (wxGetApp().app_config->get("no_warn_mixed_sublayer_variable_layer") != "1") {
            // Orca: parent to the plater like the sibling site in Plater::priv::on_action_layersediting
            // (BBS passes nullptr, which MsgDialog remaps to the main frame).
            MessageDialog dlg(wxGetApp().plater(),
                _L("Using variable layer height together with mixed color sublayer may result in poor color mixing quality."),
                _L("Warning"), wxICON_WARNING | wxOK);
            dlg.show_dsa_button();
            dlg.ShowModal();
            if (dlg.get_checkbox_state())
                wxGetApp().app_config->set("no_warn_mixed_sublayer_variable_layer", "1");
        }
    }
 
    const Selection& selection = scene_selection();
    const int obj_idx = selection.get_object_idx();
    wxDataViewItem item = obj_idx >= 0 && GetSelectedItemsCount() > 1 && selection.is_single_full_object() ?
                          m_objects_model->GetItemById(obj_idx) :
                          GetSelection();
 
    if (!item)
        return;
 
    const wxDataViewItem obj_item = m_objects_model->GetObject(item);
    wxDataViewItem layers_item = m_objects_model->GetLayerRootItem(obj_item);
 
    // if it doesn't exist now
    if (!layers_item.IsOk())
    {
        t_layer_config_ranges& ranges = object(obj_idx)->layer_config_ranges;
 
        // set some default value
        if (ranges.empty()) {
            // BBS: remove snapshot name "Add layers"
            take_snapshot(_u8L("Add layers"));
            ranges[{ 0.0f, 2.0f }].assign_config(get_default_layer_config(obj_idx));
        }
 
        // create layer root item
        layers_item = add_layer_root_item(obj_item);
    }
    if (!layers_item.IsOk())
        return;
 
    // to correct visual hints for layers editing on the Scene, reset previous selection
    wxGetApp().obj_layers()->reset_selection();
    wxGetApp().plater()->canvas3D()->handle_sidebar_focus_event("", false);
 
    // select LayerRoor item and expand
    select_item(layers_item);
    Expand(layers_item);
}

References _L, _u8L, add_layer_root_item(), Slic3r::GUI::MsgDialog::get_checkbox_state(), get_default_layer_config(), Slic3r::GUI::Selection::get_object_idx(), Slic3r::GUI::Selection::is_single_full_object(), Slic3r::ModelObject::layer_config_ranges, m_objects_model, object(), Slic3r::GUI::plater(), Slic3r::GUI::scene_selection(), select_item(), Slic3r::GUI::MsgDialog::show_dsa_button(), Slic3r::GUI::DPIAware< P >::ShowModal(), and Slic3r::GUI::take_snapshot().

Here is the call graph for this function:

list_manipulation()

void Slic3r::GUI::ObjectList::list_manipulation ( const wxPoint & mouse_pos, bool evt_context_menu = false )

private

{
    if (m_prevent_list_manipulation) return;
 
    // Interesting fact: when mouse_pos.x < 0, HitTest(mouse_pos, item, col) returns item = null, but column = last column.
    // So, when mouse was moved to scene immediately after clicking in ObjectList, in the scene will be shown context menu for the Editing column.
    if (mouse_pos.x < 0)
        return;
 
    wxDataViewItem item;
    wxDataViewColumn* col = nullptr;
    HitTest(mouse_pos, item, col);
 
    if (m_extruder_editor)
        m_extruder_editor->Hide();
 
    /* Note: Under OSX right click doesn't send "selection changed" event.
     * It means that Selection() will be return still previously selected item.
     * Thus under OSX we should force UnselectAll(), when item and col are nullptr,
     * and select new item otherwise.
     */
 
    // BBS
    //if (!item)
    {
        if (col == nullptr) {
            if (wxOSX && !multiple_selection())
                UnselectAll();
            else if (!evt_context_menu)
                // Case, when last item was deleted and under GTK was called wxEVT_DATAVIEW_SELECTION_CHANGED,
                // which invoked next list_manipulation(false)
                return;
        }
 
        if (evt_context_menu) {
            show_context_menu(evt_context_menu);
            return;
        }
    }
 
    if (wxOSX && item && col) {
        wxDataViewItemArray sels;
        GetSelections(sels);
        UnselectAll();
        if (sels.Count() > 1)
            SetSelections(sels);
        else
            Select(item);
    }
 
    if (col != nullptr)
    {
      const wxString title = col->GetTitle();
        ColumnNumber col_num = (ColumnNumber)col->GetModelColumn();
        if (col_num == colHeight)
            enable_layers_editing();
        else if (col_num == colPrint)
          toggle_printable_state();
        else if (col_num == colSupportPaint) {
            ObjectDataViewModelNode* node = (ObjectDataViewModelNode*)item.GetID();
            if (node && node->HasSupportPainting()) {
                GLGizmosManager& gizmos_mgr = wxGetApp().plater()->get_view3D_canvas3D()->get_gizmos_manager();
                if (gizmos_mgr.get_current_type() != GLGizmosManager::EType::FdmSupports)
                    gizmos_mgr.open_gizmo(GLGizmosManager::EType::FdmSupports);
                else
                    gizmos_mgr.reset_all_states();
            }
        }
        else if (col_num == colColorPaint) {
            if (wxGetApp().plater()->get_current_canvas3D()->get_canvas_type() != GLCanvas3D::CanvasAssembleView) {
                ObjectDataViewModelNode* node = (ObjectDataViewModelNode*)item.GetID();
                if (node && node->HasColorPainting()) {
                    GLGizmosManager& gizmos_mgr = wxGetApp().plater()->get_view3D_canvas3D()->get_gizmos_manager();
                    if (gizmos_mgr.get_current_type() != GLGizmosManager::EType::MmSegmentation)
                        gizmos_mgr.open_gizmo(GLGizmosManager::EType::MmSegmentation);
                    else
                        gizmos_mgr.reset_all_states();
                }
            }
        }
        else if (col_num == colSinking) {
            Plater *    plater = wxGetApp().plater();
            GLCanvas3D *cnv    = plater->canvas3D();
            if (cnv->get_canvas_type() == GLCanvas3D::ECanvasType::CanvasPreview) {//ban reload_scene in Preview scene
                return;
            }
            int obj_idx, vol_idx;
            get_selected_item_indexes(obj_idx, vol_idx, item);
            if (obj_idx != -1) {
                Plater::TakeSnapshot snapshot(plater, _u8L("Shift objects to bed"));
                // Shift on request also when auto drop is off, which ensure_on_bed() skips.
                ModelObject* mo = (*m_objects)[obj_idx];
                mo->translate_instances(-mo->min_z() * Vec3d::UnitZ());
                cnv->reload_scene(true, true);
                update_info_items(obj_idx);
                notify_instance_updated(obj_idx);
            }
        }
        else if (col_num == colEditing) {
            //show_context_menu(evt_context_menu);
            int obj_idx, vol_idx;
 
            get_selected_item_indexes(obj_idx, vol_idx, item);
            //wxGetApp().plater()->PopupObjectTable(obj_idx, vol_idx, mouse_pos);
            if (m_objects_model->GetItemType(item) & itPlate)
                dynamic_cast<TabPrintPlate*>(wxGetApp().get_plate_tab())->reset_model_config();
            else if (m_objects_model->GetItemType(item) & itLayer)
                dynamic_cast<TabPrintLayer*>(wxGetApp().get_layer_tab())->reset_model_config();
            else if (item.IsOk())
                dynamic_cast<TabPrintModel*>(wxGetApp().get_model_tab(vol_idx >= 0))->reset_model_config();
            wxGetApp().params_panel()->notify_object_config_changed();
        }
        else if (col_num == colName)
        {
            if (m_objects_model->HasWarningIcon(item) &&
                mouse_pos.x > 2 * wxGetApp().em_unit() && mouse_pos.x < 4 * wxGetApp().em_unit())
                fix_through_cgal();
            else if (evt_context_menu)
                show_context_menu(evt_context_menu); // show context menu for "Name" column too
        }
      // workaround for extruder editing under OSX
      else if (wxOSX && evt_context_menu && col_num == colFilament)
          extruder_editing();
  }
 
#ifndef __WXMSW__
    GetMainWindow()->SetToolTip(""); // hide tooltip
#endif //__WXMSW__
}

References _u8L, Slic3r::GUI::GLCanvas3D::CanvasAssembleView, Slic3r::GUI::GLCanvas3D::CanvasPreview, Slic3r::GUI::colColorPaint, Slic3r::GUI::colEditing, Slic3r::GUI::colFilament, Slic3r::GUI::colHeight, Slic3r::GUI::colName, Slic3r::GUI::colPrint, Slic3r::GUI::colSinking, Slic3r::GUI::colSupportPaint, em_unit(), enable_layers_editing(), extruder_editing(), Slic3r::GUI::GLGizmosManager::FdmSupports, fix_through_cgal(), Slic3r::GUI::GLCanvas3D::get_canvas_type(), Slic3r::GUI::GLGizmosManager::get_current_type(), get_selected_item_indexes(), Slic3r::GUI::ObjectDataViewModelNode::HasColorPainting(), Slic3r::GUI::ObjectDataViewModelNode::HasSupportPainting(), Slic3r::GUI::itLayer, Slic3r::GUI::itPlate, m_extruder_editor, m_objects_model, m_prevent_list_manipulation, Slic3r::ModelObject::min_z(), Slic3r::GUI::GLGizmosManager::MmSegmentation, multiple_selection(), notify_instance_updated(), Slic3r::GUI::GLGizmosManager::open_gizmo(), Slic3r::GUI::plater(), Slic3r::GUI::GLCanvas3D::reload_scene(), Slic3r::GUI::GLGizmosManager::reset_all_states(), show_context_menu(), toggle_printable_state(), Slic3r::ModelObject::translate_instances(), update_info_items(), and wxOSX.

Referenced by ObjectList(), and OnContextMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

load_generic_subobject()

void Slic3r::GUI::ObjectList::load_generic_subobject	(	const std::string &	type_name,
		const ModelVolumeType	type )

Any changes of the Object's composition is duplicated for all Object's Instances So, It's enough to take a bounding box of a first selected Instance and calculate Part(generic_subobject) position

{
    // BBS: single snapshot
    Plater::SingleSnapshot single(wxGetApp().plater());
 
    if (type == ModelVolumeType::INVALID) {
        load_shape_object(type_name);
        return;
    }
 
    const int obj_idx = get_selected_obj_idx();
    if (obj_idx < 0)
        return;
 
    const Selection& selection = scene_selection();
    assert(obj_idx == selection.get_object_idx());

    int instance_idx = *selection.get_instance_idxs().begin();
    assert(instance_idx != -1);
    if (instance_idx == -1)
        return;
 
    take_snapshot(_u8L("Add primitive"));
 
    // Selected object
    ModelObject  &model_object = *(*m_objects)[obj_idx];
    // Bounding box of the selected instance in world coordinate system including the translation, without modifiers.
    BoundingBoxf3 instance_bb = model_object.instance_bounding_box(instance_idx);
 
    TriangleMesh mesh = create_mesh(type_name, instance_bb);
 
  // Mesh will be centered when loading.
    ModelVolume *new_volume = model_object.add_volume(std::move(mesh), type);
 
    // First (any) GLVolume of the selected instance. They all share the same instance matrix.
    const GLVolume* v = selection.get_first_volume();
    // Transform the new modifier to be aligned with the print bed.
    new_volume->set_transformation(v->get_instance_transformation().get_matrix_no_offset().inverse());
    const BoundingBoxf3 mesh_bb = new_volume->mesh().bounding_box();
    // Set the modifier position.
    auto offset = (type_name == "Slab") ?
        // Slab: Lift to print bed
    Vec3d(0., 0., 0.5 * mesh_bb.size().z() + instance_bb.min.z() - v->get_instance_offset().z()) :
        // Translate the new modifier to be pickable: move to the left front corner of the instance's bounding box, lift to print bed.
        Vec3d(instance_bb.max.x(), instance_bb.min.y(), instance_bb.min.z()) + 0.5 * mesh_bb.size() - v->get_instance_offset();
    new_volume->set_offset(v->get_instance_transformation().get_matrix_no_offset().inverse() * offset);
 
    // BBS: backup
    Slic3r::save_object_mesh(model_object);
 
    const wxString name = _L("Generic") + "-" + _(type_name);
    new_volume->name = into_u8(name);
 
    // set a default extruder value, since user can't add it manually
    // BBS
    int extruder_id = 0;
    if (new_volume->type() == ModelVolumeType::MODEL_PART && model_object.config.has("extruder"))
        extruder_id = model_object.config.opt_int("extruder");
    new_volume->config.set_key_value("extruder", new ConfigOptionInt(extruder_id));
    new_volume->source.is_from_builtin_objects = true;
 
    select_item([this, obj_idx, new_volume]() {
        wxDataViewItem sel_item;
 
        wxDataViewItemArray items = reorder_volumes_and_get_selection(obj_idx, [new_volume](const ModelVolume* volume) { return volume == new_volume; });
        if (!items.IsEmpty())
            sel_item = items.front();
 
        return sel_item;
    });
    if (type == ModelVolumeType::MODEL_PART)
        // update printable state on canvas
        wxGetApp().plater()->get_view3D_canvas3D()->update_instance_printable_state_for_object((size_t)obj_idx);
 
    // apply the instance transform to all volumes and reset instance transform except the offset
    apply_object_instance_transfrom_to_all_volumes(&model_object);
 
    selection_changed();
 
    //BBS: notify partplate the modify
    notify_instance_updated(obj_idx);
 
    //BBS Switch to Objects List after add a modifier
    wxGetApp().params_panel()->switch_to_object(true);
 
    //Show Dialog
    if (wxGetApp().app_config->get("do_not_show_modifer_tips").empty()) {
        TipsDialog dlg(wxGetApp().mainframe, _L("Add Modifier"), _L("Switch to per-object setting mode to edit modifier settings."), "do_not_show_modifer_tips");
        dlg.ShowModal();
    }
}

References _, _L, _u8L, Slic3r::ModelObject::add_volume(), apply_object_instance_transfrom_to_all_volumes(), Slic3r::TriangleMesh::bounding_box(), Slic3r::ModelObject::config, Slic3r::ModelVolume::config, Slic3r::GUI::create_mesh(), Slic3r::GUI::Selection::get_first_volume(), Slic3r::GUI::Selection::get_instance_idxs(), Slic3r::GLVolume::get_instance_offset(), Slic3r::GLVolume::get_instance_transformation(), Slic3r::Geometry::Transformation::get_matrix_no_offset(), Slic3r::GUI::Selection::get_object_idx(), get_selected_obj_idx(), Slic3r::ModelConfig::has(), Slic3r::ModelObject::instance_bounding_box(), Slic3r::GUI::into_u8(), Slic3r::INVALID, Slic3r::ModelVolume::Source::is_from_builtin_objects, load_shape_object(), Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::max, Slic3r::ModelVolume::mesh(), Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min, Slic3r::MODEL_PART, Slic3r::ModelVolume::name, notify_instance_updated(), Slic3r::offset(), Slic3r::ModelConfig::opt_int(), Slic3r::GUI::plater(), reorder_volumes_and_get_selection(), Slic3r::save_object_mesh(), Slic3r::GUI::scene_selection(), select_item(), selection_changed(), Slic3r::ModelConfig::set_key_value(), Slic3r::ModelVolume::set_offset(), Slic3r::ModelVolume::set_transformation(), Slic3r::GUI::DPIAware< P >::ShowModal(), Slic3r::BoundingBox3Base< PointType >::size(), Slic3r::ModelVolume::source, Slic3r::GUI::take_snapshot(), and Slic3r::ModelVolume::type().

Referenced by Slic3r::GUI::Plater::_calib_pa_pattern().

Here is the call graph for this function:

Here is the caller graph for this function:

load_mesh_object() [1/2]

void Slic3r::GUI::ObjectList::load_mesh_object	(	const std::vector< std::pair< const TriangleMesh *, wxString > > &	parts,
		const wxString &	name,
		bool	center = true )

{
    // Add mesh to model as a new object
    Model& model = wxGetApp().plater()->model();
 
#ifdef _DEBUG
    check_model_ids_validity(model);
#endif /* _DEBUG */
 
    std::vector<size_t> object_idxs;
    BoundingBoxf3 bb;
    ModelObject* new_object = model.add_object();
    new_object->name = into_u8(name);
    new_object->add_instance(); // each object should have at least one instance
 
    // add_volume() centres each part on its own geometry, so the part offsets carry the
    // meshes' placement relative to each other.
    for (const auto& [mesh, part_name] : parts) {
        bb.merge(mesh->bounding_box());
        ModelVolume* new_volume = new_object->add_volume(*mesh);
        new_volume->name = into_u8(part_name);
    }
    new_object->sort_volumes(true);
    // set a default extruder value, since user can't add it manually
    // BBS
    new_object->config.set_key_value("extruder", new ConfigOptionInt(1));
    new_object->invalidate_bounding_box();
    new_object->translate(-bb.center());
 
    // BBS: backup
    Slic3r::save_object_mesh(*new_object);
 
    // BBS: find an empty cell to put the copied object
    auto start_point = wxGetApp().plater()->build_volume().bed_center();
    auto empty_cell  = wxGetApp().plater()->canvas3D()->get_nearest_empty_cell({start_point(0), start_point(1)});
 
    new_object->instances[0]->set_offset(center ? to_3d(Vec2d(empty_cell(0), empty_cell(1)), -new_object->origin_translation.z()) : bb.center());
 
    new_object->ensure_on_bed();
 
    //BBS init assmeble transformation
    Geometry::Transformation t = new_object->instances[0]->get_transformation();
    new_object->instances[0]->set_assemble_transformation(t);
 
    object_idxs.push_back(model.objects.size() - 1);
#ifdef _DEBUG
    check_model_ids_validity(model);
#endif /* _DEBUG */
 
    paste_objects_into_list(object_idxs);
 
#ifdef _DEBUG
    check_model_ids_validity(model);
#endif /* _DEBUG */
}

References Slic3r::ModelObject::add_instance(), Slic3r::Model::add_object(), Slic3r::ModelObject::add_volume(), Slic3r::BoundingBox3Base< PointType >::center(), Slic3r::center(), Slic3r::check_model_ids_validity(), Slic3r::ModelObject::config, Slic3r::ModelObject::ensure_on_bed(), Slic3r::ModelObject::instances, Slic3r::GUI::into_u8(), Slic3r::ModelObject::invalidate_bounding_box(), Slic3r::BoundingBox3Base< PointType >::merge(), Slic3r::ModelObject::name, Slic3r::ModelVolume::name, Slic3r::Model::objects, Slic3r::ModelObject::origin_translation, paste_objects_into_list(), Slic3r::save_object_mesh(), Slic3r::ModelConfig::set_key_value(), Slic3r::ModelObject::sort_volumes(), Slic3r::to_3d(), and Slic3r::ModelObject::translate().

Here is the call graph for this function:

load_mesh_object() [2/2]

void Slic3r::GUI::ObjectList::load_mesh_object	(	const TriangleMesh &	mesh,
		const wxString &	name,
		bool	center = true )

{
    load_mesh_object(std::vector<std::pair<const TriangleMesh*, wxString>>{{&mesh, name}}, name, center);
}

References Slic3r::center(), and load_mesh_object().

Referenced by load_mesh_object(), and load_shape_object().

Here is the call graph for this function:

Here is the caller graph for this function:

load_modifier()

void Slic3r::GUI::ObjectList::load_modifier	(	const wxArrayString &	input_files,
		ModelObject &	model_object,
		std::vector< ModelVolume * > &	added_volumes,
		ModelVolumeType	type,
		bool	from_galery = false )

Any changes of the Object's composition is duplicated for all Object's Instances So, It's enough to take a bounding box of a first selected Instance and calculate Part(generic_subobject) position

{
    // ! ysFIXME - delete commented code after testing and rename "load_modifier" to something common
    //if (type == ModelVolumeType::MODEL_PART)
    //    return;
 
    wxWindow* parent = wxGetApp().tab_panel()->GetPage(0);
 
    ProgressDialog dlg(_L("Loading") + dots, "", 100, wxGetApp().mainframe, wxPD_AUTO_HIDE);
 
    wxBusyCursor busy;
 
    const int obj_idx = get_selected_obj_idx();
    if (obj_idx < 0)
        return;
 
    const Selection& selection = scene_selection();
    assert(obj_idx == selection.get_object_idx());

    int instance_idx = *selection.get_instance_idxs().begin();
    assert(instance_idx != -1);
    if (instance_idx == -1)
        return;
 
    // Bounding box of the selected instance in world coordinate system including the translation, without modifiers.
    const BoundingBoxf3 instance_bb = model_object.instance_bounding_box(instance_idx);
 
    // First (any) GLVolume of the selected instance. They all share the same instance matrix.
    const GLVolume* v = selection.get_first_volume();
    const Geometry::Transformation inst_transform = v->get_instance_transformation();
    const Transform3d inv_inst_transform = inst_transform.get_matrix_no_offset().inverse();
    const Vec3d instance_offset = v->get_instance_offset();
 
    for (size_t i = 0; i < input_files.size(); ++i) {
        const std::string input_file = input_files.Item(i).ToUTF8().data();
 
        dlg.Update(static_cast<int>(100.0f * static_cast<float>(i) / static_cast<float>(input_files.size())),
            _L("Loading file") + ": " + from_path(boost::filesystem::path(input_file).filename()));
        dlg.Fit();
        
        bool is_user_cancel = false;
        Model model;
        try {
            if (boost::iends_with(input_file, ".stp") ||
                boost::iends_with(input_file, ".step")) {
                double linear  = string_to_double_decimal_point(wxGetApp().app_config->get("linear_deflection"));
                if (linear <= 0) linear = 0.003;
                double angle = string_to_double_decimal_point(wxGetApp().app_config->get("angle_deflection"));
                if (angle <= 0) angle = 0.5;
                bool split_compound = wxGetApp().app_config->get_bool("is_split_compound");
                model = Model::read_from_step(
                    input_file, LoadStrategy::LoadModel, nullptr, nullptr,
                    [&is_user_cancel, &linear, &angle, &split_compound](Slic3r::Step& file, double& linear_value,
                                                                                     double& angle_value, bool& is_split) -> int {
                        if (wxGetApp().app_config->get_bool("enable_step_mesh_setting")) {
                            StepMeshDialog mesh_dlg(nullptr, file, linear, angle);
                            if (mesh_dlg.ShowModal() == wxID_OK) {
                                linear_value = mesh_dlg.get_linear_deflection();
                                angle_value  = mesh_dlg.get_angle_deflection();
                                is_split     = mesh_dlg.get_split_compound_value();
                                return 1;
                            }
                        } else {
                            linear_value = linear;
                            angle_value  = angle;
                            is_split     = split_compound;
                            return 1;
                        }
                        is_user_cancel = true;
                        return -1;
                    },
                    linear, angle, split_compound);
            } else {
                model = Model::read_from_file(input_file, nullptr, nullptr, LoadStrategy::LoadModel);
            }
        }
        catch (std::exception&) {
            if (!is_user_cancel) {
                // auto msg = _L("Error!") + " " + input_file + " : " + e.what() + ".";
                auto msg = _L("Error!") + " " + _L("Failed to get the model data in the current file.");
                show_error(parent, msg);
            }
            return;
        }
 
        if (from_galery)
            model.center_instances_around_point(Vec2d::Zero());
        else {
            for (auto object : model.objects) {
                if (model_object.origin_translation != Vec3d::Zero()) {
                    object->center_around_origin();
                    const Vec3d delta = model_object.origin_translation - object->origin_translation;
                    for (auto volume : object->volumes) {
                        volume->translate(delta);
                    }
                }
            }
        }
 
        model.add_default_instances();
        TriangleMesh mesh = model.mesh();
        // Mesh will be centered when loading.
        ModelVolume* new_volume = model_object.add_volume(std::move(mesh), type);
        new_volume->name = boost::filesystem::path(input_file).filename().string();
 
        // adjust offset as prusaslicer ObjectList::load_from_files does (works) instead of BBS method
        //TriangleMesh object_mesh = model_object.volumes[0]->mesh();
        //new_volume->set_offset(new_volume->mesh().get_init_shift() - object_mesh.get_init_shift());
 
        // set a default extruder value, since user can't add it manually
        // BBS
        int extruder_id = 0;
        if (new_volume->type() == ModelVolumeType::MODEL_PART && model_object.config.has("extruder"))
            extruder_id = model_object.config.opt_int("extruder");
        new_volume->config.set_key_value("extruder", new ConfigOptionInt(extruder_id));
        // update source data
        new_volume->source.input_file = input_file;
        new_volume->source.object_idx = obj_idx;
        new_volume->source.volume_idx = int(model_object.volumes.size()) - 1;
        if (model.objects.size() == 1 && model.objects.front()->volumes.size() == 1)
            new_volume->source.mesh_offset = model.objects.front()->volumes.front()->source.mesh_offset;
 
        if (from_galery) {
            // Transform the new modifier to be aligned with the print bed.
            const BoundingBoxf3 mesh_bb = new_volume->mesh().bounding_box();
            new_volume->set_transformation(Geometry::Transformation::volume_to_bed_transformation(inst_transform, mesh_bb));
            // Set the modifier position.
            // Translate the new modifier to be pickable: move to the left front corner of the instance's bounding box, lift to print bed.
            const Vec3d offset = Vec3d(instance_bb.max.x(), instance_bb.min.y(), instance_bb.min.z()) + 0.5 * mesh_bb.size() - instance_offset;
            new_volume->set_offset(inv_inst_transform * offset);
        }
        else
            new_volume->set_offset(new_volume->source.mesh_offset - model_object.volumes.front()->source.mesh_offset);
 
        added_volumes.push_back(new_volume);
    }
}

References _L, Slic3r::Model::add_default_instances(), Slic3r::ModelObject::add_volume(), Slic3r::angle(), Slic3r::TriangleMesh::bounding_box(), Slic3r::Model::center_instances_around_point(), Slic3r::ModelObject::config, Slic3r::ModelVolume::config, Slic3r::GUI::dots(), Slic3r::GUI::from_path(), StepMeshDialog::get_angle_deflection(), Slic3r::GUI::Selection::get_first_volume(), Slic3r::GUI::Selection::get_instance_idxs(), Slic3r::GLVolume::get_instance_offset(), Slic3r::GLVolume::get_instance_transformation(), StepMeshDialog::get_linear_deflection(), Slic3r::Geometry::Transformation::get_matrix_no_offset(), Slic3r::GUI::Selection::get_object_idx(), get_selected_obj_idx(), StepMeshDialog::get_split_compound_value(), Slic3r::ModelConfig::has(), Slic3r::ModelVolume::Source::input_file, Slic3r::ModelObject::instance_bounding_box(), Slic3r::LoadModel, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::max, Slic3r::Model::mesh(), Slic3r::ModelVolume::mesh(), Slic3r::ModelVolume::Source::mesh_offset, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min, Slic3r::MODEL_PART, Slic3r::ModelVolume::name, object(), Slic3r::ModelVolume::Source::object_idx, Slic3r::Model::objects, Slic3r::offset(), Slic3r::ModelConfig::opt_int(), Slic3r::ModelObject::origin_translation, Slic3r::Model::read_from_file(), Slic3r::Model::read_from_step(), Slic3r::GUI::scene_selection(), Slic3r::ModelConfig::set_key_value(), Slic3r::ModelVolume::set_offset(), Slic3r::ModelVolume::set_transformation(), Slic3r::GUI::show_error(), Slic3r::GUI::DPIAware< P >::ShowModal(), Slic3r::BoundingBox3Base< PointType >::size(), Slic3r::ModelVolume::source, Slic3r::string_to_double_decimal_point(), Slic3r::ModelVolume::type(), Slic3r::GUI::ProgressDialog::Update(), Slic3r::ModelVolume::Source::volume_idx, Slic3r::Geometry::Transformation::volume_to_bed_transformation(), and Slic3r::ModelObject::volumes.

Referenced by load_subobject().

Here is the call graph for this function:

Here is the caller graph for this function:

load_shape_object()

void Slic3r::GUI::ObjectList::load_shape_object

(

const std::string &

type_name

)

{
    const Selection& selection = wxGetApp().plater()->canvas3D()->get_selection();
    //assert(selection.get_object_idx() == -1); // Add nothing is something is selected on 3DScene
    if (selection.get_object_idx() != -1)
        return;
 
    const int obj_idx = m_objects->size();
    if (obj_idx < 0)
        return;
 
    Plater::TakeSnapshot snapshot(wxGetApp().plater(), _u8L("Add Primitive"));
 
    // Create mesh
    BoundingBoxf3 bb;
    TriangleMesh mesh = create_mesh(type_name, bb);
    // Rotate the largest overhang area toward the part cooling fan so new shapes start in a
    // cooling friendly orientation. Skip the plain cube: the pressure advance pattern
    // calibration reuses it as an axis-aligned anchor and scales it by its bounding box,
    // so its orientation must stay fixed.
    const Slic3r::DynamicPrintConfig& full_config = wxGetApp().preset_bundle->full_config();
    if (type_name != "Cube" && full_config.has("fan_direction") && full_config.has("auxiliary_fan")) {
        FanDirection config_dir = full_config.option<ConfigOptionEnum<FanDirection>>("fan_direction")->value;
        orientation::orient_for_cooling(mesh, config_dir);
    }
    // BBS: remove "Shape" prefix
    load_mesh_object(mesh, _(type_name));
    wxGetApp().mainframe->update_title();
}

References _, _u8L, Slic3r::GUI::create_mesh(), Slic3r::GUI::Selection::get_object_idx(), Slic3r::ConfigOptionResolver::has(), load_mesh_object(), m_objects, Slic3r::ConfigBase::option(), Slic3r::orientation::orient_for_cooling(), and Slic3r::GUI::plater().

Referenced by load_generic_subobject().

Here is the call graph for this function:

Here is the caller graph for this function:

load_subobject()

void Slic3r::GUI::ObjectList::load_subobject	(	ModelVolumeType	type,
		bool	from_galery = false )

{
    wxDataViewItem item = GetSelection();
    // we can add volumes for Object or Instance
    if (!item || !(m_objects_model->GetItemType(item)&(itObject|itInstance)))
        return;
    const int obj_idx = m_objects_model->GetObjectIdByItem(item);
 
    if (obj_idx < 0) return;
 
    // Get object item, if Instance is selected
    if (m_objects_model->GetItemType(item)&itInstance)
        item = m_objects_model->GetItemById(obj_idx);
 
    wxArrayString input_files;
    /*if (from_galery) {
        GalleryDialog dlg(this);
        if (dlg.ShowModal() != wxID_CLOSE)
            dlg.get_input_files(input_files);
    }
    else*/
        wxGetApp().import_model(wxGetApp().tab_panel()->GetPage(0), input_files);
 
    if (input_files.IsEmpty())
        return;
 
    take_snapshot((type == ModelVolumeType::MODEL_PART) ? _u8L("Load Part") : _u8L("Load Modifier"));
 
    std::vector<ModelVolume*> volumes;
    // ! ysFIXME - delete commented code after testing and rename "load_modifier" to something common
    /*
    if (type == ModelVolumeType::MODEL_PART)
        load_part(*(*m_objects)[obj_idx], volumes, type, from_galery);
    else*/
        load_modifier(input_files, *(*m_objects)[obj_idx], volumes, type, from_galery);
 
    if (volumes.empty())
        return;
 
    wxDataViewItemArray items = reorder_volumes_and_get_selection(obj_idx, [volumes](const ModelVolume* volume) {
        return std::find(volumes.begin(), volumes.end(), volume) != volumes.end(); });
 
    if (type == ModelVolumeType::MODEL_PART)
        // update printable state on canvas
        wxGetApp().plater()->get_view3D_canvas3D()->update_instance_printable_state_for_object((size_t)obj_idx);
 
    if (items.size() > 1) {
        m_selection_mode = smVolume;
        m_last_selected_item = wxDataViewItem(nullptr);
    }
    select_items(items);
 
    selection_changed();
 
    //BBS: notify partplate the modify
    notify_instance_updated(obj_idx);
}

References _u8L, Slic3r::GUI::itInstance, Slic3r::GUI::itObject, load_modifier(), m_last_selected_item, m_objects, m_objects_model, m_selection_mode, Slic3r::MODEL_PART, notify_instance_updated(), reorder_volumes_and_get_selection(), select_items(), selection_changed(), smVolume, and Slic3r::GUI::take_snapshot().

Here is the call graph for this function:

merge()

void Slic3r::GUI::ObjectList::merge

(

bool

to_multipart_object

)

{
    wxBusyCursor wait;
    // merge selected objects to the multipart object
    if (to_multipart_object) {
        auto get_object_idxs = [this](std::vector<int>& obj_idxs, wxDataViewItemArray& sels)
        {
            // check selections and split instances to the separated objects...
            bool instance_selection = false;
            for (wxDataViewItem item : sels)
                if (m_objects_model->GetItemType(item) & itInstance) {
                    instance_selection = true;
                    break;
                }
 
            if (!instance_selection) {
                for (wxDataViewItem item : sels) {
                    assert(m_objects_model->GetItemType(item) & itObject);
                    obj_idxs.emplace_back(m_objects_model->GetIdByItem(item));
                }
                return;
            }
 
            // map of obj_idx -> set of selected instance_idxs
            std::map<int, std::set<int>> sel_map;
            std::set<int> empty_set;
            for (wxDataViewItem item : sels) {
                if (m_objects_model->GetItemType(item) & itObject) {
                    int obj_idx = m_objects_model->GetIdByItem(item);
                    int inst_cnt = (*m_objects)[obj_idx]->instances.size();
                    if (inst_cnt == 1)
                        sel_map.emplace(obj_idx, empty_set);
                    else
                        for (int i = 0; i < inst_cnt; i++)
                            sel_map[obj_idx].emplace(i);
                    continue;
                }
                int obj_idx = m_objects_model->GetIdByItem(m_objects_model->GetObject(item));
                sel_map[obj_idx].emplace(m_objects_model->GetInstanceIdByItem(item));
            }
 
            // all objects, created from the instances will be added to the end of list
            int new_objects_cnt = 0; // count of this new objects
 
            for (auto map_item : sel_map) {
                int obj_idx = map_item.first;
                // object with just 1 instance
                if (map_item.second.empty()) {
                    obj_idxs.emplace_back(obj_idx);
                    continue;
                }
 
                // object with selected all instances
                if ((*m_objects)[map_item.first]->instances.size() == map_item.second.size()) {
                    instances_to_separated_objects(obj_idx);
                    // first instance stay on its own place and another all add to the end of list :
                    obj_idxs.emplace_back(obj_idx);
                    new_objects_cnt += map_item.second.size() - 1;
                    continue;
                }
 
                // object with selected some of instances
                instances_to_separated_object(obj_idx, map_item.second);
 
                if (map_item.second.size() == 1)
                    new_objects_cnt += 1;
                else {// we should split to separate instances last object
                    instances_to_separated_objects(m_objects->size() - 1);
                    // all instances will stay at the end of list :
                    new_objects_cnt += map_item.second.size();
                }
            }
 
            // all instatnces are extracted to the separate objects and should be selected
            m_prevent_list_events = true;
            sels.Clear();
            for (int obj_idx : obj_idxs)
                sels.Add(m_objects_model->GetItemById(obj_idx));
            int obj_cnt = m_objects->size();
            for (int obj_idx = obj_cnt - new_objects_cnt; obj_idx < obj_cnt; obj_idx++) {
                sels.Add(m_objects_model->GetItemById(obj_idx));
                obj_idxs.emplace_back(obj_idx);
            }
            UnselectAll();
            SetSelections(sels);
            assert(!sels.IsEmpty());
            m_prevent_list_events = false;
        };
 
        std::vector<int> obj_idxs;
        wxDataViewItemArray sels;
        GetSelections(sels);
        assert(!sels.IsEmpty());
 
        Plater::TakeSnapshot snapshot(wxGetApp().plater(), _u8L("Assemble"));
 
        get_object_idxs(obj_idxs, sels);
 
        // resulted objects merge to the one
        Model* model = (*m_objects)[0]->get_model();
        ModelObject* new_object = model->add_object();
        new_object->name = _u8L("Assembly");
        ModelConfig &config = new_object->config;
 
        Slic3r::SaveObjectGaurd gaurd(*new_object);
 
        for (int obj_idx : obj_idxs) {
            ModelObject* object = (*m_objects)[obj_idx];
 
            const Geometry::Transformation& transformation = object->instances[0]->get_transformation();
            //const Vec3d scale     = transformation.get_scaling_factor();
            //const Vec3d mirror    = transformation.get_mirror();
            //const Vec3d rotation  = transformation.get_rotation();
 
            if (object->id() == (*m_objects)[obj_idxs.front()]->id())
                new_object->add_instance();
            const Transform3d& transformation_matrix = transformation.get_matrix();
 
            // merge volumes
            for (const ModelVolume* volume : object->volumes) {
                ModelVolume* new_volume = new_object->add_volume(*volume);
 
                //BBS: keep volume's transform
                const Transform3d& volume_matrix = new_volume->get_matrix();
                Transform3d new_matrix = transformation_matrix * volume_matrix;
                new_volume->set_transformation(new_matrix);
                //set rotation
                /*const Vec3d vol_rot = new_volume->get_rotation() + rotation;
                new_volume->set_rotation(vol_rot);
 
                // set scale
                const Vec3d vol_sc_fact = new_volume->get_scaling_factor().cwiseProduct(scale);
                new_volume->set_scaling_factor(vol_sc_fact);
 
                // set mirror
                const Vec3d vol_mirror = new_volume->get_mirror().cwiseProduct(mirror);
                new_volume->set_mirror(vol_mirror);
 
                // set offset
                const Vec3d vol_offset = volume_offset_correction* new_volume->get_offset();
                new_volume->set_offset(vol_offset);*/
 
                //BBS: add config from old objects
                //for object config, it has settings of PrintObjectConfig and PrintRegionConfig
                //for volume config, it only has settings of PrintRegionConfig
                //so we can not copy settings from object to volume
                //but we can copy settings from volume to object
                if (object->volumes.size() > 1){
                    new_volume->config.assign_config(volume->config);
                }
                auto option = new_volume->config.option("extruder");
                if (!option) {
                    auto opt = object->config.option("extruder");
                    if (opt) { new_volume->config.set_key_value("extruder", new ConfigOptionInt(opt->getInt())); }
                }
            }
            new_object->sort_volumes(true);
 
            // merge settings
            auto new_opt_keys = config.keys();
            const ModelConfig& from_config = object->config;
            auto opt_keys = from_config.keys();
 
            for (auto& opt_key : opt_keys) {
                if (find(new_opt_keys.begin(), new_opt_keys.end(), opt_key) == new_opt_keys.end()) {
                    const ConfigOption* option = from_config.option(opt_key);
                    if (!option) {
                        // if current option doesn't exist in prints.get_edited_preset(),
                        // get it from default config values
                        option = DynamicPrintConfig::new_from_defaults_keys({ opt_key })->option(opt_key);
                    }
                    config.set_key_value(opt_key, option->clone());
                }
            }
            // save extruder value if it was set
            if (object->volumes.size() == 1 && find(opt_keys.begin(), opt_keys.end(), "extruder") != opt_keys.end()) {
                ModelVolume* volume = new_object->volumes.back();
                const ConfigOption* option = from_config.option("extruder");
                if (option)
                    volume->config.set_key_value("extruder", option->clone());
            }
 
            // merge printable and auto_drop values
            // non-default have priority -> if one object has printable == false, 
            // then merged object will also have printable == false
            if (object->instances[0]->printable == false) {
                new_object->printable = false;
                new_object->instances[0]->printable = false;
            }
            if (object->auto_drop == false) {
                new_object->auto_drop = false;
            }
 
            // merge layers
            for (const auto& range : object->layer_config_ranges)
                new_object->layer_config_ranges.emplace(range);
 
            // merge brim ears
            BrimPoints temp_brim_points = object->brim_points;
            for(auto& p : temp_brim_points) {
                p.set_transform(transformation_matrix);
                new_object->brim_points.push_back(p);
            }
        }
 
        //BBS: ensure on bed, and no need to center around origin
        new_object->ensure_on_bed();
        new_object->center_around_origin();
        new_object->translate_instances(-new_object->origin_translation);
        new_object->origin_translation = Vec3d::Zero();
        //BBS init asssmble transformation
        Geometry::Transformation new_object_trsf = new_object->instances[0]->get_transformation();
        new_object->instances[0]->set_assemble_transformation(new_object_trsf);
 
        const Transform3d& new_object_inverse_matrix = new_object_trsf.get_matrix().inverse();
        for (auto& p : new_object->brim_points) {
            p.set_transform(new_object_inverse_matrix);
        }
        //BBS: notify it before remove
        notify_instance_updated(m_objects->size() - 1);
 
        // remove selected objects
        remove();
 
        // Add new object(merged) to the object_list
        add_object_to_list(m_objects->size() - 1);
        if (new_object->printable == false) {
            wxGetApp().obj_list()->printable_state_changed({new_object});
        }
        select_item(m_objects_model->GetItemById(m_objects->size() - 1));
        update_selections_on_canvas();
    }
    // merge all parts to the one single object
    // all part's settings will be lost
    else {
        wxDataViewItem item = GetSelection();
        if (!item)
            return;
        const int obj_idx = m_objects_model->GetIdByItem(item);
        if (obj_idx == -1)
            return;
 
        Plater::TakeSnapshot snapshot(wxGetApp().plater(), _u8L("Merge parts to an object"));
 
        ModelObject* model_object = (*m_objects)[obj_idx];
        model_object->merge();
 
        m_objects_model->DeleteVolumeChildren(item);
 
        changed_object(obj_idx);
    }
}

References _u8L, Slic3r::ModelObject::add_instance(), Slic3r::Model::add_object(), add_object_to_list(), Slic3r::ModelObject::add_volume(), Slic3r::ModelConfig::assign_config(), Slic3r::ModelObject::auto_drop, Slic3r::ModelObject::brim_points, Slic3r::ModelObject::center_around_origin(), changed_object(), Slic3r::ConfigOption::clone(), config(), Slic3r::ModelObject::config, Slic3r::ModelVolume::config, Slic3r::ModelObject::ensure_on_bed(), Slic3r::Geometry::Transformation::get_matrix(), Slic3r::ModelVolume::get_matrix(), Slic3r::ModelObject::instances, instances_to_separated_object(), instances_to_separated_objects(), Slic3r::GUI::itInstance, Slic3r::GUI::itObject, Slic3r::ModelConfig::keys(), Slic3r::ModelObject::layer_config_ranges, m_objects, m_objects_model, m_prevent_list_events, Slic3r::ModelObject::merge(), Slic3r::ModelObject::name, Slic3r::DynamicPrintConfig::new_from_defaults_keys(), notify_instance_updated(), object(), Slic3r::ModelConfig::option(), Slic3r::ModelObject::origin_translation, Slic3r::GUI::plater(), Slic3r::ModelObject::printable, Slic3r::range(), remove(), select_item(), Slic3r::ModelConfig::set_key_value(), Slic3r::ModelVolume::set_transformation(), Slic3r::ModelObject::sort_volumes(), Slic3r::ModelObject::translate_instances(), update_selections_on_canvas(), and Slic3r::ModelObject::volumes.

Here is the call graph for this function:

msw_rescale()

void Slic3r::GUI::ObjectList::msw_rescale

(

)

{
    set_min_height();
 
    const int em = wxGetApp().em_unit();
 
    for (int cn = colName; cn < colCount; cn++)
        GetColumn(cn)->SetWidth(m_columns_width[cn] * em);
 
    // Keep the explicit row height (see create_objects_ctrl) in sync with the
    // rescaled em so the filament colour badge keeps fitting after a DPI or theme
    // change.
    SetRowHeight(2 * em + FromDIP(2));
 
    // rescale/update existing items with bitmaps
    m_objects_model->Rescale();
 
    Layout();
}

References Slic3r::GUI::colCount, Slic3r::GUI::colName, m_columns_width, m_objects_model, and set_min_height().

Referenced by sys_color_changed().

Here is the call graph for this function:

Here is the caller graph for this function:

multiple_selection()

bool Slic3r::GUI::ObjectList::multiple_selection

(

)

const

{
    return GetSelectedItemsCount() > 1;
}

Referenced by list_manipulation(), OnBeginDrag(), part_selection_changed(), show_context_menu(), and Slic3r::GUI::ObjectLayers::update_layers_list().

Here is the caller graph for this function:

notify_instance_updated()

void Slic3r::GUI::ObjectList::notify_instance_updated

(

int

obj_idx

)

{
    const int inst_cnt = (*m_objects)[obj_idx]->instances.size();
    PartPlateList& list = wxGetApp().plater()->get_partplate_list();
    for (int index = 0; index < inst_cnt; index ++)
        list.notify_instance_update(obj_idx, index);
}

References Slic3r::GUI::PartPlateList::notify_instance_update().

Referenced by boolean(), del_subobject_from_object(), list_manipulation(), load_generic_subobject(), load_subobject(), merge(), OnEditingStarted(), paste_volumes_into_list(), and split().

Here is the call graph for this function:

Here is the caller graph for this function:

object()

ModelObject * Slic3r::GUI::ObjectList::object

(

const int

obj_idx

)

const

{
    if (obj_idx < 0)
        return nullptr;
 
    return (*m_objects)[obj_idx];
}

References m_objects.

Referenced by add_layer_item(), add_layer_range_after_current(), add_volumes_to_object_in_list(), Slic3r::GUI::MenuFactory::append_menu_item_printable(), Slic3r::GUI::MenuFactory::append_menu_item_set_printable(), Slic3r::GUI::MenuFactory::append_menu_items_flush_options(), boolean(), can_add_new_range_after_current(), copy_layers_to_clipboard(), del_layer_from_object(), del_layer_range(), del_layers_from_object(), del_subobject_from_object(), delete_all_connectors_for_object(), delete_from_model_and_list(), delete_from_model_and_list(), edit_layer_range(), edit_layer_range(), fix_cut_selection(), fix_through_cgal(), get_default_layer_config(), instances_to_separated_objects(), invalidate_cut_info_for_object(), layers_editing(), load_modifier(), merge(), OnDrop(), part_selection_changed(), paste_layers_into_list(), reorder_volumes_and_get_selection(), show_context_menu(), smooth_mesh(), toggle_auto_drop(), toggle_printable_state(), update_filament_values_for_items(), update_filament_values_for_items_when_delete_filament(), update_item_error_icon(), Slic3r::GUI::ObjectLayers::update_layers_list(), update_name_in_model(), update_printable_state(), and update_selections_on_canvas().

Here is the caller graph for this function:

object_config_options_changed()

void Slic3r::GUI::ObjectList::object_config_options_changed

(

const ObjectVolumeID &

ov_id

)

{
    if (ov_id.object == nullptr)
        return;
 
    ModelObjectPtrs& objects = wxGetApp().model().objects;
    ModelObject* mo = ov_id.object;
    ModelVolume* mv = ov_id.volume;
 
    wxDataViewItem obj_item = m_objects_model->GetObjectItem(mo);
    if (mv != nullptr) {
        size_t vol_idx;
        for (vol_idx = 0; vol_idx < mo->volumes.size(); vol_idx++) {
            if (mo->volumes[vol_idx] == mv)
                break;
        }
        assert(vol_idx < mo->volumes.size());
 
        SettingsFactory::Bundle cat_options = SettingsFactory::get_bundle(&mv->config.get(), false);
        wxDataViewItem vol_item = m_objects_model->GetVolumeItem(obj_item, vol_idx);
        if (cat_options.size() > 0) {
            add_settings_item(vol_item, &mv->config.get());
        }
        else {
            m_objects_model->DeleteSettings(vol_item);
        }
    }
    else {
        SettingsFactory::Bundle cat_options = SettingsFactory::get_bundle(&mo->config.get(), true);
        if (cat_options.size() > 0) {
            add_settings_item(obj_item, &mo->config.get());
        }
        else {
            m_objects_model->DeleteSettings(obj_item);
        }
    }
}

References add_settings_item(), Slic3r::ModelObject::config, Slic3r::ModelVolume::config, Slic3r::ModelConfig::get(), Slic3r::GUI::SettingsFactory::get_bundle(), m_objects_model, Slic3r::GUI::ObjectVolumeID::object, objects(), Slic3r::GUI::ObjectVolumeID::volume, and Slic3r::ModelObject::volumes.

Here is the call graph for this function:

objects()

std::vector< ModelObject * > * Slic3r::GUI::ObjectList::objects ( ) const

inline

{ return m_objects; }

References m_objects.

Referenced by object_config_options_changed(), select_items(), and anonymous_namespace{EmbossJob.cpp}::update_name_in_list().

Here is the caller graph for this function:

on_plate_added()

void Slic3r::GUI::ObjectList::on_plate_added

(

PartPlate *

part_plate

)

{
    wxDataViewItem plate_item = m_objects_model->AddPlate(part_plate);
}

References m_objects_model.

on_plate_deleted()

void Slic3r::GUI::ObjectList::on_plate_deleted

(

int

plate_index

)

{
    m_objects_model->DeletePlate(plate_idx);
 
    wxDataViewItemArray top_list;
    m_objects_model->GetChildren(wxDataViewItem(nullptr), top_list);
    for (wxDataViewItem item : top_list) {
        Expand(item);
    }
}

References m_objects_model.

on_plate_selected()

void Slic3r::GUI::ObjectList::on_plate_selected

(

int

plate_index

)

{
    wxDataViewItem item = m_objects_model->GetItemByPlateId(plate_index);
    wxDataViewItem sel = GetSelection();
 
    if (sel == item)
        return;
 
    UnselectAll();
    Select(item);
}

References m_objects_model.

Referenced by select_items().

Here is the caller graph for this function:

OnBeginDrag()

void Slic3r::GUI::ObjectList::OnBeginDrag ( wxDataViewEvent & event )

private

{
    const bool mult_sel = multiple_selection();
    if (mult_sel) {
        event.Veto();
        return;
    }
 
    const wxDataViewItem item(event.GetItem());
    const ItemType& type = m_objects_model->GetItemType(item);
    if (!(type & (itVolume | itObject))) {
        event.Veto();
        return;
    }
 
    if (type & itObject) {
        m_dragged_data.init(m_objects_model->GetIdByItem(item), type);
    }
    else if (type & itVolume){
        m_dragged_data.init(m_objects_model->GetObjectIdByItem(item), m_objects_model->GetVolumeIdByItem(item), type);
    }
#if 0
    if ((mult_sel && !selected_instances_of_same_object()) ||
        (!mult_sel && (GetSelection() != item)) ) {
        event.Veto();
        return;
    }
 
    if (!(type & (itVolume | itObject | itInstance))) {
        event.Veto();
        return;
    }
 
    if (mult_sel)
    {
        m_dragged_data.init(m_objects_model->GetObjectIdByItem(item),type);
        std::set<int>& sub_obj_idxs = m_dragged_data.inst_idxs();
        wxDataViewItemArray sels;
        GetSelections(sels);
        for (auto sel : sels )
            sub_obj_idxs.insert(m_objects_model->GetInstanceIdByItem(sel));
    }
    else if (type & itObject)
        m_dragged_data.init(m_objects_model->GetIdByItem(item), type);
    else
        m_dragged_data.init(m_objects_model->GetObjectIdByItem(item),
                            type&itVolume ? m_objects_model->GetVolumeIdByItem(item) :
                                        m_objects_model->GetInstanceIdByItem(item),
                            type);
#endif
 
    /* Under MSW or OSX, DnD moves an item to the place of another selected item
    * But under GTK, DnD moves an item between another two items.
    * And as a result - call EVT_CHANGE_SELECTION to unselect all items.
    * To prevent such behavior use m_prevent_list_events
    **/
    m_prevent_list_events = true;//it's needed for GTK
 
    /* Under GTK, DnD requires to the wxTextDataObject been initialized with some valid value,
     * so set some nonempty string
     */
    wxTextDataObject* obj = new wxTextDataObject;
    obj->SetText("Some text");//it's needed for GTK
 
    event.SetDataObject(obj);
    event.SetDragFlags(wxDrag_DefaultMove); // allows both copy and move;
}

References Slic3r::GUI::itInstance, Slic3r::GUI::itObject, Slic3r::GUI::itVolume, m_dragged_data, m_objects_model, m_prevent_list_events, multiple_selection(), and selected_instances_of_same_object().

Referenced by ObjectList().

Here is the call graph for this function:

Here is the caller graph for this function:

OnContextMenu()

void Slic3r::GUI::ObjectList::OnContextMenu ( wxDataViewEvent & event )

private

{
    // The mouse position returned by get_mouse_position_in_control() here is the one at the time the mouse button is released (mouse up event)
    wxPoint mouse_pos = this->get_mouse_position_in_control();
 
    // Do not show the context menu if the user pressed the right mouse button on the 3D scene and released it on the objects list
    GLCanvas3D* canvas = wxGetApp().plater()->canvas3D();
    bool evt_context_menu = (canvas != nullptr) ? !canvas->is_mouse_dragging() : true;
    if (!evt_context_menu)
        canvas->mouse_up_cleanup();
 
    list_manipulation(mouse_pos, evt_context_menu);
}

References get_mouse_position_in_control(), Slic3r::GUI::GLCanvas3D::is_mouse_dragging(), list_manipulation(), and Slic3r::GUI::GLCanvas3D::mouse_up_cleanup().

Referenced by ObjectList().

Here is the call graph for this function:

Here is the caller graph for this function:

OnDrop()

void Slic3r::GUI::ObjectList::OnDrop ( wxDataViewEvent & event )

private

{
    const wxDataViewItem& item = event.GetItem();
 
    int src_obj_id, src_plate, dest_obj_id, dest_plate;
    if (!can_drop(item, src_obj_id, src_plate, dest_obj_id, dest_plate))
    {
        event.Veto();
        m_dragged_data.clear();
        return;
    }
 
//#if 1
    take_snapshot(_u8L("Object order changed"));
 
    if(m_dragged_data.type() & itObject){
        int delta = dest_obj_id < src_obj_id ? -1 : 1;
        PartPlateList& partplate_list = wxGetApp().plater()->get_partplate_list();
        /*int cnt = 0, cur_id = src_obj_id, next_id, total = abs(src_obj_id - dest_obj_id);
        //for (cur_id = src_obj_id; cnt < total; id += delta, cnt++)
        next_id = src_obj_id + delta;
        while (cnt < total)
        {
            int cur_plate = partplate_list.find_instance(next_id, 0);
            if (cur_plate != src_plate) {
                cnt ++;
                next_id += delta;
                continue;
            }
            std::swap((*m_objects)[cur_id], (*m_objects)[next_id]);
            cur_id = next_id;
            cnt ++;
            next_id += delta;
        }*/
 
        int cnt = 0;
        for (int id = src_obj_id; cnt < abs(src_obj_id - dest_obj_id); id += delta, cnt++)
            std::swap((*m_objects)[id], (*m_objects)[id + delta]);
 
        select_item(m_objects_model->ReorganizeObjects(src_obj_id, dest_obj_id));
 
        partplate_list.reload_all_objects(false, src_plate);
        changed_object(src_obj_id);
    }
    else if (m_dragged_data.type() & itVolume) {
        int from_volume_id = m_dragged_data.sub_obj_idx();
        int to_volume_id   = m_objects_model->GetVolumeIdByItem(item);
        int delta          = to_volume_id < from_volume_id ? -1 : 1;
 
        const int obj_idx = m_dragged_data.obj_idx();
        // Object-indexed UI maps may be stale after another object is removed or reordered.
        if (obj_idx < 0 || size_t(obj_idx) >= m_objects->size()) {
            event.Veto();
            m_dragged_data.clear();
            return;
        }
        const ModelObject *object = (*m_objects)[obj_idx];
        auto &volumes = (*m_objects)[obj_idx]->volumes;
        std::vector<size_t> visible_volume_indices;
        visible_volume_indices.reserve(volumes.size());
        for (size_t idx = 0; idx < volumes.size(); ++idx)
            // Match add_volumes_to_object_in_list: only connectors of cut objects are hidden.
            if (!(object->is_cut() && volumes[idx]->is_cut_connector()))
                visible_volume_indices.push_back(idx);
 
        // Validate the entire move before any swap; these checks must also protect Release builds.
        if (from_volume_id < 0 || to_volume_id < 0 ||
            size_t(from_volume_id) >= visible_volume_indices.size() || size_t(to_volume_id) >= visible_volume_indices.size()) {
            event.Veto();
            m_dragged_data.clear();
            return;
        }
 
        // Move through visible slots only, keeping hidden cut connectors at their original indices.
        // The local mapping stays valid because no hidden volume changes slots during the move.
        for (int id = from_volume_id; id != to_volume_id; id += delta) {
            const size_t current_idx = visible_volume_indices[id];
            const size_t next_idx = visible_volume_indices[id + delta];
            std::swap(volumes[current_idx], volumes[next_idx]);
        }
 
        // Later selection/filament handlers use this cache; repair it for the moved object too.
        auto &ui_to_model = m_objects_model->get_ui_and_3d_volume_map()[obj_idx];
        ui_to_model.clear();
        for (size_t idx = 0; idx < visible_volume_indices.size(); ++idx)
            ui_to_model[int(idx)] = int(visible_volume_indices[idx]);
 
        select_item(m_objects_model->ReorganizeChildren(from_volume_id, to_volume_id, m_objects_model->GetParent(item)));
 
        changed_object(m_dragged_data.obj_idx());
    }
 
    m_dragged_data.clear();
 
    wxGetApp().plater()->set_current_canvas_as_dirty();
}

References _u8L, can_drop(), changed_object(), Slic3r::GUI::itObject, Slic3r::GUI::itVolume, m_dragged_data, m_objects, m_objects_model, object(), Slic3r::GUI::PartPlateList::reload_all_objects(), select_item(), Slic3r::GUI::take_snapshot(), and Slic3r::ModelObject::volumes.

Referenced by ObjectList().

Here is the call graph for this function:

Here is the caller graph for this function:

OnDropPossible()

void Slic3r::GUI::ObjectList::OnDropPossible ( wxDataViewEvent & event )

private

{
    const wxDataViewItem& item = event.GetItem();
 
    int src_obj_id, src_plate, dest_obj_id, dest_plate;
    if (!can_drop(item, src_obj_id, src_plate, dest_obj_id, dest_plate)) {
        event.Veto();
        m_prevent_list_events = false;
    }
}

References can_drop(), and m_prevent_list_events.

Referenced by ObjectList().

Here is the call graph for this function:

Here is the caller graph for this function:

OnEditingDone()

void Slic3r::GUI::ObjectList::OnEditingDone ( wxDataViewEvent & event )

private

{
    if (event.GetColumn() != colName)
        return;
 
    if (event.IsEditCancelled()) {
        if (m_objects_model->GetItemType(event.GetItem()) & itPlate) {
            int plate_idx = -1;
            m_objects_model->GetItemType(event.GetItem(), plate_idx);
            if (plate_idx >= 0) {
                auto plate = wxGetApp().plater()->get_partplate_list().get_plate(plate_idx);
                m_objects_model->SetCurSelectedPlateFullName(plate_idx, plate->get_plate_name());
            }
        }
    }
 
    const auto renderer = dynamic_cast<BitmapTextRenderer*>(GetColumn(colName)->GetRenderer());
#if __WXOSX__
    SetAcceleratorTable(m_accel);
#endif
 
    if (renderer->WasCanceled())
    wxTheApp->CallAfter([this]{ Plater::show_illegal_characters_warning(this); });
 
#ifdef __WXMSW__
  // Workaround for entering the column editing mode on Windows. Simulate keyboard enter when another column of the active line is selected.
  // Here the last active column is forgotten, so when leaving the editing mode, the next mouse click will not enter the editing mode of the newly selected column.
  m_last_selected_column = -1;
#endif //__WXMSW__
 
    Plater* plater = wxGetApp().plater();
    if (plater)
        plater->set_current_canvas_as_dirty();
}

References Slic3r::GUI::colName, Slic3r::GUI::itPlate, m_objects_model, Slic3r::GUI::plater(), and Slic3r::GUI::Plater::show_illegal_characters_warning().

Referenced by ObjectList().

Here is the call graph for this function:

Here is the caller graph for this function:

OnEditingStarted()

void Slic3r::GUI::ObjectList::OnEditingStarted ( wxDataViewEvent & event )

private

{
#ifdef __WXMSW__
  m_last_selected_column = -1;
#else
    event.Veto(); // Not edit with NSTableView's text
    auto col = event.GetColumn();
    auto item = event.GetItem();
    if (col == colPrint) {
        toggle_printable_state();
        return;
    } else if (col == colSupportPaint) {
        ObjectDataViewModelNode* node = (ObjectDataViewModelNode*)item.GetID();
        if (node->HasSupportPainting()) {
            GLGizmosManager& gizmos_mgr = wxGetApp().plater()->get_view3D_canvas3D()->get_gizmos_manager();
            if (gizmos_mgr.get_current_type() != GLGizmosManager::EType::FdmSupports)
                gizmos_mgr.open_gizmo(GLGizmosManager::EType::FdmSupports);
            else
                gizmos_mgr.reset_all_states();
        }
        return;
    }
    else if (col == colColorPaint) {
        ObjectDataViewModelNode* node = (ObjectDataViewModelNode*)item.GetID();
        if (node->HasColorPainting()) {
            GLGizmosManager& gizmos_mgr = wxGetApp().plater()->get_view3D_canvas3D()->get_gizmos_manager();
            if (gizmos_mgr.get_current_type() != GLGizmosManager::EType::MmSegmentation)
                gizmos_mgr.open_gizmo(GLGizmosManager::EType::MmSegmentation);
            else
                gizmos_mgr.reset_all_states();
        }
        return;
    }
    else if (col == colSinking) {
        Plater *    plater = wxGetApp().plater();
        GLCanvas3D *cnv    = plater->canvas3D();
        Plater::TakeSnapshot snapshot(plater, _u8L("Shift objects to bed"));
        int obj_idx, vol_idx;
        get_selected_item_indexes(obj_idx, vol_idx, item);
        // Shift on request also when auto drop is off, which ensure_on_bed() skips.
        ModelObject* mo = (*m_objects)[obj_idx];
        mo->translate_instances(-mo->min_z() * Vec3d::UnitZ());
        cnv->reload_scene(true, true);
        update_info_items(obj_idx);
        notify_instance_updated(obj_idx);
    }
    else if (col == colEditing) {
        //show_context_menu(evt_context_menu);
        int obj_idx, vol_idx;
 
        get_selected_item_indexes(obj_idx, vol_idx, item);
        //wxGetApp().plater()->PopupObjectTable(obj_idx, vol_idx, mouse_pos);
        dynamic_cast<TabPrintModel*>(wxGetApp().get_model_tab(vol_idx >= 0))->reset_model_config();
        return;
    }
#ifdef __WXOSX__
    if (col == colFilament) {
        start_filament_editor(item);
        return;
    }
#endif // __WXOSX__
    if (col != colFilament && col != colName)
        return;
    auto column = GetColumn(col);
    const auto renderer = column->GetRenderer();
    if (!renderer->GetEditorCtrl()) {
        renderer->StartEditing(item, GetItemRect(item, column));
        if (col == colName) // TODO: for colName editing, disable shortcuts
            SetAcceleratorTable(wxNullAcceleratorTable);
    }
#ifdef __WXOSX__
    SetCustomRendererPtr(dynamic_cast<wxDataViewCustomRenderer*>(renderer));
#endif
#endif //__WXMSW__
}

References _u8L, Slic3r::GUI::colColorPaint, Slic3r::GUI::colEditing, Slic3r::GUI::colFilament, Slic3r::GUI::colName, Slic3r::GUI::colPrint, Slic3r::GUI::colSinking, Slic3r::GUI::colSupportPaint, Slic3r::GUI::GLGizmosManager::FdmSupports, Slic3r::GUI::GLGizmosManager::get_current_type(), get_selected_item_indexes(), Slic3r::GUI::ObjectDataViewModelNode::HasColorPainting(), Slic3r::GUI::ObjectDataViewModelNode::HasSupportPainting(), Slic3r::ModelObject::min_z(), Slic3r::GUI::GLGizmosManager::MmSegmentation, notify_instance_updated(), Slic3r::GUI::GLGizmosManager::open_gizmo(), Slic3r::GUI::plater(), Slic3r::GUI::GLCanvas3D::reload_scene(), Slic3r::GUI::GLGizmosManager::reset_all_states(), toggle_printable_state(), Slic3r::ModelObject::translate_instances(), and update_info_items().

Referenced by ObjectList().

Here is the call graph for this function:

Here is the caller graph for this function:

OnStartEditing()

void Slic3r::GUI::GUI::ObjectList::OnStartEditing ( wxDataViewEvent & event )

private

{
    auto col  = event.GetColumn();
    auto item = event.GetItem();
#ifdef __WXOSX__
    if (col == colFilament) {
        if (m_starting_filament_editor)
            return;
 
        event.Veto();
        CallAfter([this, item] {
            if (!is_live_model_item(item))
                return;
            start_filament_editor(item);
        });
        return;
    }
#endif // __WXOSX__
 
    if (col == colName) {
        ObjectDataViewModelNode* node = (ObjectDataViewModelNode*)item.GetID();
        if (node->GetType() & itPlate) {
            int plate_idx = node->GetPlateIdx();
            if (plate_idx >= 0) {
                auto plate = wxGetApp().plater()->get_partplate_list().get_plate(plate_idx);
                m_objects_model->SetName(from_u8(plate->get_plate_name()), GetSelection());
            }
        }
    }
}

References Slic3r::GUI::colFilament, Slic3r::GUI::colName, Slic3r::GUI::from_u8(), Slic3r::GUI::ObjectDataViewModelNode::GetPlateIdx(), Slic3r::GUI::ObjectDataViewModelNode::GetType(), Slic3r::GUI::itPlate, and m_objects_model.

Referenced by ObjectList().

Here is the call graph for this function:

Here is the caller graph for this function:

part_selection_changed()

void Slic3r::GUI::ObjectList::part_selection_changed

(

)

{
    if (wxGetApp().is_closing())
        return;
 
    if (m_extruder_editor) m_extruder_editor->Hide();
    int obj_idx = -1;
    int volume_id = -1;
    m_config = nullptr;
    wxString og_name = wxEmptyString;
 
    bool update_and_show_manipulations = false;
    bool update_and_show_settings = false;
    bool update_and_show_layers = false;
 
    bool enable_manipulation{true};
    bool disable_ss_manipulation{false};
    bool disable_ununiform_scale{false};
 
    const auto item = GetSelection();
    if (item && m_objects_model->GetItemType(item) == itInfo && m_objects_model->GetInfoItemType(item) == InfoItemType::CutConnectors) {
        og_name = _L("Cut Connectors information");
 
        update_and_show_manipulations = true;
        enable_manipulation           = false;
        disable_ununiform_scale       = true;
    }
    else if (item && (m_objects_model->GetItemType(item) & itPlate)) {
        // BBS
        // TODO: og for plate
    }
    else if ( multiple_selection() || (item && m_objects_model->GetItemType(item) == itInstanceRoot )) {
        const Selection& selection = scene_selection();
 
        if (selection.is_single_full_object()) {
            og_name                       = _L("Object manipulation");
            update_and_show_manipulations = true;
 
            obj_idx                 = selection.get_object_idx();
            ModelObject *object     = (*m_objects)[obj_idx];
            m_config                = &object->config;
            disable_ss_manipulation = object->is_cut();
        }
        else {
            og_name = _L("Group manipulation");
 
            // don't show manipulation panel for case of all Object's parts selection
            update_and_show_manipulations = !selection.is_single_full_instance();
 
            if (int obj_idx = selection.get_object_idx(); obj_idx >= 0) {
                if (selection.is_any_volume() || selection.is_any_modifier())
                    enable_manipulation = !(*m_objects)[obj_idx]->is_cut();
                else // if (item && m_objects_model->GetItemType(item) == itInstanceRoot)
                    disable_ss_manipulation = (*m_objects)[obj_idx]->is_cut();
            }
            else {
                wxDataViewItemArray sels;
                GetSelections(sels);
                if (selection.is_single_full_object() || selection.is_multiple_full_instance()) {
                    int obj_idx             = m_objects_model->GetObjectIdByItem(sels.front());
                    disable_ss_manipulation = (*m_objects)[obj_idx]->is_cut();
                } else if (selection.is_mixed() || selection.is_multiple_full_object()) {
                    std::map<CutObjectBase, std::set<int>> cut_objects;
 
                    // find cut objects
                    for (auto item : sels) {
                        int                obj_idx = m_objects_model->GetObjectIdByItem(item);
                        const ModelObject *obj     = object(obj_idx);
                        if (obj && obj->is_cut()) {
                            if (cut_objects.find(obj->cut_id) == cut_objects.end())
                                cut_objects[obj->cut_id] = std::set<int>{obj_idx};
                            else
                                cut_objects.at(obj->cut_id).insert(obj_idx);
                        }
                    }
 
                    // check if selected cut objects are "full selected"
                    for (auto cut_object : cut_objects)
                        if (cut_object.first.check_sum() != cut_object.second.size()) {
                            disable_ss_manipulation = true;
                            break;
                        }
                    disable_ununiform_scale = !cut_objects.empty();
                }
            }
        }
 
        // BBS: multi config editing
        update_and_show_settings = true;
    }
    else {
        if (item) {
            // BBS
            const ItemType type = m_objects_model->GetItemType(item);
            const wxDataViewItem parent = m_objects_model->GetParent(item);
            const ItemType parent_type = m_objects_model->GetItemType(parent);
            obj_idx = m_objects_model->GetObjectIdByItem(item);
 
            if ((type & itObject) || type == itInfo) {
                m_config = &(*m_objects)[obj_idx]->config;
                update_and_show_manipulations = true;
 
                if (type == itInfo) {
                    InfoItemType info_type = m_objects_model->GetInfoItemType(item);
                    switch (info_type)
                    {
                    case InfoItemType::CustomSupports:
                    // BBS: remove CustomSeam
                    //case InfoItemType::CustomSeam:
                    case InfoItemType::MmSegmentation:
                    case InfoItemType::FuzzySkin:
                    {
                        GLGizmosManager::EType gizmo_type = info_type == InfoItemType::CustomSupports ? GLGizmosManager::EType::FdmSupports :
                                                            /*info_type == InfoItemType::CustomSeam ? GLGizmosManager::EType::Seam :*/
                                                            info_type == InfoItemType::FuzzySkin        ? GLGizmosManager::EType::FuzzySkin :
                                                            GLGizmosManager::EType::MmSegmentation;
                        GLGizmosManager& gizmos_mgr = wxGetApp().plater()->get_view3D_canvas3D()->get_gizmos_manager();
                        if (gizmos_mgr.get_current_type() != gizmo_type)
                            gizmos_mgr.open_gizmo(gizmo_type);
                        break;
                    }
                    // BBS: remove Sinking
                    //case InfoItemType::Sinking: { break; }
                    default: { break; }
                    }
                } else {
                    // BBS: select object to edit config
                    m_config = &(*m_objects)[obj_idx]->config;
                    update_and_show_settings = true;
                    disable_ss_manipulation  = (*m_objects)[obj_idx]->is_cut();
                }
            }
            else {
                if (type & itSettings) {
                    if (parent_type & itObject) {
                        og_name  = _L("Object Settings to Modify");
                        m_config = &(*m_objects)[obj_idx]->config;
                    }
                    else if (parent_type & itVolume) {
                        og_name   = _L("Part Settings to Modify");
                        volume_id = m_objects_model->GetVolumeIdByItem(parent);
                        m_config = &(*m_objects)[obj_idx]->volumes[volume_id]->config;
                    }
                    else if (parent_type & itLayer) {
                        og_name  = _L("Layer Range Settings to Modify");
                        m_config = &get_item_config(parent);
                    }
                    update_and_show_settings = true;
                }
                else if (type & itVolume) {
                    og_name = _L("Part manipulation");
                    volume_id = m_objects_model->GetVolumeIdByItem(item);
                    m_config = &(*m_objects)[obj_idx]->volumes[volume_id]->config;
                    update_and_show_manipulations = true;
                    m_config = &(*m_objects)[obj_idx]->volumes[volume_id]->config;
                    update_and_show_settings = true;
 
                    const ModelVolume *volume = (*m_objects)[obj_idx]->volumes[volume_id];
                    enable_manipulation       = !((*m_objects)[obj_idx]->is_cut() && (volume->is_cut_connector() || volume->is_model_part()));
                }
                else if (type & itInstance) {
                    og_name = _L("Instance manipulation");
                    update_and_show_manipulations = true;
 
                    // fill m_config by object's values
                    m_config = &(*m_objects)[obj_idx]->config;
                    disable_ss_manipulation = (*m_objects)[obj_idx]->is_cut();
                }
                else if (type & (itLayerRoot | itLayer)) {
                    og_name = type & itLayerRoot ? _L("Height ranges") : _L("Settings for height range");
                    update_and_show_layers = true;
                    update_and_show_settings = true;
 
                    if (type & itLayer)
                        m_config = &get_item_config(item);
                }
            }
        }
    }
 
    m_selected_object_id = obj_idx;
 
    if (update_and_show_manipulations) {
        // BBS
        //wxGetApp().obj_manipul()->get_og()->set_name(" " + og_name + " ");
 
        if (item) {
            // wxGetApp().obj_manipul()->get_og()->set_value("object_name", m_objects_model->GetName(item));
            // BBS
            //wxGetApp().obj_manipul()->update_item_name(m_objects_model->GetName(item));
            //wxGetApp().obj_manipul()->update_warning_icon_state(get_mesh_errors_info(obj_idx, volume_id));
        }
 
        GLGizmosManager &gizmos_mgr = wxGetApp().plater()->canvas3D()->get_gizmos_manager();
 
        if (GLGizmoScale3D *scale = dynamic_cast<GLGizmoScale3D *>(gizmos_mgr.get_gizmo(GLGizmosManager::Scale)))
            scale->enable_ununiversal_scale(!disable_ununiform_scale);
    }
 
#if !NEW_OBJECT_SETTING
    if (update_and_show_settings)
        wxGetApp().obj_settings()->get_og()->set_name(" " + og_name + " ");
#endif
 
    if (!this->IsShown())
        update_and_show_layers = false;
    if (printer_technology() == ptSLA)
        update_and_show_layers = false;
    else if (update_and_show_layers) {
        ;//wxGetApp().obj_layers()->get_og()->set_name(" " + og_name + " ");
    }
 
    update_min_height();
 
    Sidebar& panel = wxGetApp().sidebar();
    panel.Freeze();
 
 
    const ItemType type = m_objects_model->GetItemType(item);
    if (!(type & itLayer)) {
        wxGetApp().plater()->canvas3D()->handle_sidebar_focus_event("", false);
    }
    // BBS
    //wxGetApp().obj_manipul() ->UpdateAndShow(update_and_show_manipulations);
    wxGetApp().obj_settings()->UpdateAndShow(update_and_show_settings);
    wxGetApp().obj_layers()  ->UpdateAndShow(update_and_show_layers);
    wxGetApp().plater()->show_object_info();
 
    panel.Layout();
    panel.Thaw();
}

References _L, Slic3r::GUI::CustomSupports, Slic3r::ModelObject::cut_id, Slic3r::GUI::CutConnectors, Slic3r::GUI::GLGizmosManager::FdmSupports, Slic3r::GUI::GLGizmosManager::FuzzySkin, Slic3r::GUI::FuzzySkin, Slic3r::GUI::GLGizmosManager::get_current_type(), Slic3r::GUI::GLGizmosManager::get_gizmo(), get_item_config(), Slic3r::GUI::Selection::get_object_idx(), Slic3r::GUI::Selection::is_any_modifier(), Slic3r::GUI::Selection::is_any_volume(), Slic3r::ModelObject::is_cut(), Slic3r::ModelVolume::is_cut_connector(), Slic3r::GUI::Selection::is_mixed(), Slic3r::ModelVolume::is_model_part(), Slic3r::GUI::Selection::is_multiple_full_instance(), Slic3r::GUI::Selection::is_multiple_full_object(), Slic3r::GUI::Selection::is_single_full_instance(), Slic3r::GUI::Selection::is_single_full_object(), Slic3r::GUI::itInfo, Slic3r::GUI::itInstance, Slic3r::GUI::itInstanceRoot, Slic3r::GUI::itLayer, Slic3r::GUI::itLayerRoot, Slic3r::GUI::itObject, Slic3r::GUI::itPlate, Slic3r::GUI::itSettings, Slic3r::GUI::itVolume, m_config, m_extruder_editor, m_objects_model, m_selected_object_id, Slic3r::GUI::GLGizmosManager::MmSegmentation, Slic3r::GUI::MmSegmentation, multiple_selection(), object(), Slic3r::GUI::GLGizmosManager::open_gizmo(), Slic3r::GUI::printer_technology(), Slic3r::ptSLA, Slic3r::GUI::GLGizmosManager::Scale, scale(), Slic3r::GUI::scene_selection(), and update_min_height().

Referenced by delete_all_objects_from_list(), delete_from_model_and_list(), paste_settings_into_list(), select_item(), select_item(), select_items(), select_object_item(), selection_changed(), unselect_objects(), update_and_show_object_settings_item(), and update_selections().

Here is the call graph for this function:

Here is the caller graph for this function:

paste()

void Slic3r::GUI::ObjectList::paste

(

)

{
    wxPostEvent((wxEvtHandler*)wxGetApp().plater()->canvas3D()->get_wxglcanvas(), SimpleEvent(EVT_GLTOOLBAR_PASTE));
}

References Slic3r::GUI::plater().

Referenced by dispatch_shortcut().

Here is the call graph for this function:

Here is the caller graph for this function:

paste_from_clipboard()

bool Slic3r::GUI::ObjectList::paste_from_clipboard

(

)

{
    if (!(m_clipboard.get_type() & (itSettings | itLayer | itLayerRoot))) {
        m_clipboard.reset();
        return false;
    }
 
    if (m_clipboard.get_type() & itSettings)
        paste_settings_into_list();
    else if (m_clipboard.get_type() & (itLayer | itLayerRoot))
        paste_layers_into_list();
 
    return true;
}

References Slic3r::GUI::itLayer, Slic3r::GUI::itLayerRoot, Slic3r::GUI::itSettings, m_clipboard, paste_layers_into_list(), and paste_settings_into_list().

Here is the call graph for this function:

paste_layers_into_list()

void Slic3r::GUI::ObjectList::paste_layers_into_list

(

)

{
    const int obj_idx = m_objects_model->GetObjectIdByItem(GetSelection());
    t_layer_config_ranges& cache_ranges = m_clipboard.get_ranges_cache();
 
    if (obj_idx < 0 || (int)m_objects->size() <= obj_idx ||
        cache_ranges.empty() || printer_technology() == ptSLA)
        return;
 
    const wxDataViewItem object_item = m_objects_model->GetItemById(obj_idx);
    wxDataViewItem layers_item = m_objects_model->GetLayerRootItem(object_item);
    if (layers_item)
        m_objects_model->Delete(layers_item);
 
    t_layer_config_ranges& ranges = object(obj_idx)->layer_config_ranges;
 
    // and create Layer item(s) according to the layer_config_ranges
    for (const auto& range : cache_ranges)
        ranges.emplace(range);
 
    layers_item = add_layer_root_item(object_item);
 
    changed_object(obj_idx);
 
    select_item(layers_item);
#ifndef __WXOSX__
    selection_changed();
#endif //no __WXOSX__
}

References add_layer_root_item(), changed_object(), Slic3r::ModelObject::layer_config_ranges, m_clipboard, m_objects, m_objects_model, object(), Slic3r::GUI::printer_technology(), Slic3r::ptSLA, Slic3r::range(), select_item(), and selection_changed().

Referenced by paste_from_clipboard().

Here is the call graph for this function:

Here is the caller graph for this function:

paste_objects_into_list()

void Slic3r::GUI::ObjectList::paste_objects_into_list

(

const std::vector< size_t > &

object_idxs

)

{
    if (object_idxs.empty())
        return;
 
    wxDataViewItemArray items;
    for (const size_t object : object_idxs)
    {
        add_object_to_list(object);
        items.Add(m_objects_model->GetItemById(object));
    }
 
    wxGetApp().plater()->changed_objects(object_idxs);
 
    select_items(items);
    selection_changed();
}

References add_object_to_list(), m_objects_model, select_items(), and selection_changed().

Referenced by anonymous_namespace{EmbossJob.cpp}::CreateObjectJob::finalize(), and load_mesh_object().

Here is the call graph for this function:

Here is the caller graph for this function:

paste_settings_into_list()

void Slic3r::GUI::ObjectList::paste_settings_into_list

(

)

{
    wxDataViewItemArray sels;
    GetSelections(sels);
    take_snapshot(_u8L("Paste settings"));
 
    std::unique_ptr<t_config_option_keys> global_keys; // need copy from global
 
    for (auto item : sels) {
 
        if (m_objects_model->GetItemType(item) & itSettings)
            item = m_objects_model->GetParent(item);
 
        ItemType item_type = m_objects_model->GetItemType(item);
        if(!(item_type & (itObject | itVolume |itLayer)))
            return;
 
        DynamicPrintConfig& config_cache = m_clipboard.get_config_cache();
        assert(!config_cache.empty());
 
        auto keys = config_cache.keys();
        auto part_options = SettingsFactory::get_options(true);
        auto config       = &get_item_config(item);
        auto extruder     = config->option("extruder") ? config->option("extruder")->clone() : nullptr;
        config->reset();
 
        if (item_type & (itVolume | itLayer)) {
            if (global_keys == nullptr) {
                auto object = m_objects_model->GetParent(item);
                DynamicPrintConfig config;
                config.apply_only(*wxGetApp().get_tab(Preset::TYPE_PRINT)->get_config(), keys);
                config.apply_only(get_item_config(object).get(), keys);
                auto equals = config.equal(config_cache);
                global_keys.reset(new t_config_option_keys);
                auto keys2 = get_item_config(object).keys();
                std::copy_if(keys2.begin(), keys2.end(), std::back_inserter(*global_keys),
                             [&equals](auto &e) { return std::find(equals.begin(), equals.end(), e) == equals.end(); });
                keys.erase(std::remove_if(keys.begin(), keys.end(),
                             [&equals](auto &e) { return std::find(equals.begin(), equals.end(), e) != equals.end(); }), keys.end());
            }
            config->apply_only(*wxGetApp().get_tab(Preset::TYPE_PRINT)->get_config(), *global_keys);
        }
 
        for (const std::string& opt_key: keys) {
            if (item_type & (itVolume | itLayer) &&
                std::find(part_options.begin(), part_options.end(), opt_key) == part_options.end())
                continue; // we can't to add object specific options for the part's(itVolume | itLayer) config
 
            const ConfigOption* option = config_cache.option(opt_key);
            if (option)
                config->set_key_value(opt_key, option->clone());
        }
        if (extruder)
            config->set_key_value("extruder", extruder);
        else
            config->erase("extruder");
 
        // Add settings item for object/sub-object and show them
        add_settings_item(item, &config->get());
    }
 
    part_selection_changed();
}

References _u8L, add_settings_item(), Slic3r::ConfigOption::clone(), config(), Slic3r::DynamicConfig::empty(), get_item_config(), Slic3r::GUI::SettingsFactory::get_options(), Slic3r::GUI::itLayer, Slic3r::GUI::itObject, Slic3r::GUI::itSettings, Slic3r::GUI::itVolume, Slic3r::DynamicConfig::keys(), Slic3r::ModelConfig::keys(), m_clipboard, m_objects_model, Slic3r::ConfigBase::option(), part_selection_changed(), Slic3r::GUI::take_snapshot(), and Slic3r::Preset::TYPE_PRINT.

Referenced by paste_from_clipboard().

Here is the call graph for this function:

Here is the caller graph for this function:

paste_volumes_into_list()

void Slic3r::GUI::ObjectList::paste_volumes_into_list	(	int	obj_idx,
		const ModelVolumePtrs &	volumes )

{
    if ((obj_idx < 0) || ((int)m_objects->size() <= obj_idx))
        return;
 
    if (volumes.empty())
        return;
 
    wxDataViewItemArray items = reorder_volumes_and_get_selection(obj_idx, [volumes](const ModelVolume* volume) {
        return std::find(volumes.begin(), volumes.end(), volume) != volumes.end(); });
    if (items.size() > 1) {
        m_selection_mode = smVolume;
        m_last_selected_item = wxDataViewItem(nullptr);
    }
 
    select_items(items);
    selection_changed();
 
    //BBS: notify partplate the modify
    notify_instance_updated(obj_idx);
}

References m_last_selected_item, m_objects, m_selection_mode, notify_instance_updated(), reorder_volumes_and_get_selection(), select_items(), selection_changed(), and smVolume.

Here is the call graph for this function:

printable_state_changed() [1/2]

void Slic3r::GUI::ObjectList::printable_state_changed

(

const std::vector< ModelObject * >

model_objects

)

{
    std::vector<size_t> obj_idxs;
    for (const ModelObject* mo : model_objects) {
        if (mo == nullptr)
            continue;
 
        ModelInstance* mi       = mo->instances[0];
        wxDataViewItem obj_item = m_objects_model->GetObjectItem(mo);
        m_objects_model->SetObjectPrintableState(mi->printable ? piPrintable : piUnprintable, obj_item);
 
        int obj_idx = m_objects_model->GetObjectIdByItem(obj_item);
        obj_idxs.emplace_back(static_cast<size_t>(obj_idx));
    }
 
    sort(obj_idxs.begin(), obj_idxs.end());
    obj_idxs.erase(unique(obj_idxs.begin(), obj_idxs.end()), obj_idxs.end());
 
    // update printable state on canvas
    wxGetApp().plater()->get_view3D_canvas3D()->update_instance_printable_state_for_objects(obj_idxs);
 
    // update scene
    wxGetApp().plater()->update();
}

References m_objects_model, Slic3r::GUI::piPrintable, Slic3r::GUI::piUnprintable, and Slic3r::ModelInstance::printable.

Referenced by printable_state_changed().

Here is the caller graph for this function:

printable_state_changed() [2/2]

void Slic3r::GUI::ObjectList::printable_state_changed

(

const std::vector< ObjectVolumeID > &

ov_ids

)

{
    std::vector<ModelObject*> model_objects;
    model_objects.reserve(ov_ids.size());
 
    for (const ObjectVolumeID& ov_id : ov_ids) {
        if (ov_id.object != nullptr)
            model_objects.emplace_back(ov_id.object);
    }
 
    printable_state_changed(model_objects);
}

References printable_state_changed().

Here is the call graph for this function:

redo()

void Slic3r::GUI::ObjectList::redo

(

)

{
  wxGetApp().plater()->redo();
}

Referenced by dispatch_shortcut().

Here is the caller graph for this function:

reload_all_plates()

void Slic3r::GUI::ObjectList::reload_all_plates

(

bool

notify_partplate = false

)

{
    m_prevent_canvas_selection_update = true;
 
    // Unselect all objects before deleting them, so that no change of selection is emitted during deletion.
 
    /* To avoid execution of selection_changed()
     * from wxEVT_DATAVIEW_SELECTION_CHANGED emitted from DeleteAll(),
     * wrap this two functions into m_prevent_list_events *
     * */
    m_prevent_list_events = true;
    this->UnselectAll();
    m_objects_model->ResetAll();
    m_prevent_list_events = false;
 
    PartPlateList& ppl = wxGetApp().plater()->get_partplate_list();
    for (int i = 0; i < ppl.get_plate_count(); i++) {
        PartPlate* pp = ppl.get_plate(i);
        m_objects_model->AddPlate(pp, wxEmptyString);
    }
 
    size_t obj_idx = 0;
    std::vector<size_t> obj_idxs;
    obj_idxs.reserve(m_objects->size());
    while (obj_idx < m_objects->size()) {
        add_object_to_list(obj_idx, false, notify_partplate);
        obj_idxs.push_back(obj_idx);
        ++obj_idx;
    }
 
    update_selections();
 
    m_prevent_canvas_selection_update = false;
 
    // update scene
    wxGetApp().plater()->update();
    // update printable states on canvas
    wxGetApp().plater()->get_view3D_canvas3D()->update_instance_printable_state_for_objects(obj_idxs);
}

References add_object_to_list(), Slic3r::GUI::PartPlateList::get_plate(), Slic3r::GUI::PartPlateList::get_plate_count(), m_objects, m_objects_model, m_prevent_canvas_selection_update, m_prevent_list_events, and update_selections().

Referenced by delete_all_objects_from_list(), and update_after_undo_redo().

Here is the call graph for this function:

Here is the caller graph for this function:

remove()

void Slic3r::GUI::ObjectList::remove

(

)

{
    if (GetSelectedItemsCount() == 0)
        return;
 
    auto delete_item = [this](wxDataViewItem item)
    {
        wxDataViewItem parent = m_objects_model->GetParent(item);
        ItemType type = m_objects_model->GetItemType(item);
        if (type & itObject)
            delete_from_model_and_list(itObject, m_objects_model->GetIdByItem(item), -1);
        else {
            if (type & (itLayer | itInstance)) {
                // In case there is just one layer or two instances and we delete it, del_subobject_item will
                // also remove the parent item. Selection should therefore pass to the top parent (object).
                wxDataViewItemArray children;
                if (m_objects_model->GetChildren(parent, children) == (type & itLayer ? 1 : 2))
                    parent = m_objects_model->GetObject(item);
            }
 
            del_subobject_item(item);
        }
 
        return parent;
    };
 
    wxDataViewItemArray sels;
    GetSelections(sels);
 
    wxDataViewItem parent = wxDataViewItem(nullptr);
 
    if (sels.Count() == 1)
        parent = delete_item(GetSelection());
    else
    {
        SELECTION_MODE sels_mode = m_selection_mode;
        UnselectAll();
        update_selection(sels, sels_mode, m_objects_model);
 
        Plater::TakeSnapshot snapshot = Plater::TakeSnapshot(wxGetApp().plater(), _u8L("Delete selected"));
 
        for (auto& item : sels)
        {
            if (m_objects_model->InvalidItem(item)) // item can be deleted for this moment (like last 2 Instances or Volumes)
                continue;
            parent = delete_item(item);
        }
    }
 
    if (parent && !m_objects_model->InvalidItem(parent)) {
        select_item(parent);
        update_selections_on_canvas();
    }
}

References _u8L, del_subobject_item(), delete_from_model_and_list(), Slic3r::GUI::itInstance, Slic3r::GUI::itLayer, Slic3r::GUI::itObject, m_objects_model, m_selection_mode, Slic3r::GUI::plater(), select_item(), Slic3r::GUI::update_selection(), and update_selections_on_canvas().

Referenced by boolean(), dispatch_shortcut(), and merge().

Here is the call graph for this function:

Here is the caller graph for this function:

rename_item()

void Slic3r::GUI::ObjectList::rename_item

(

)

{
    const wxDataViewItem item = GetSelection();
    if (!item || !(m_objects_model->GetItemType(item) & (itVolume | itObject)))
        return ;
 
    const wxString new_name = wxGetTextFromUser(_(L("Enter new name"))+":", _(L("Renaming")),
                                                m_objects_model->GetName(item), this);
 
    if (new_name.IsEmpty())
        return;
 
    if (Plater::has_illegal_filename_characters(new_name)) {
        Plater::show_illegal_characters_warning(this);
        return;
    }
 
    if (m_objects_model->SetName(new_name, item))
        update_name_in_model(item);
}

References _, Slic3r::GUI::Plater::has_illegal_filename_characters(), Slic3r::GUI::itObject, Slic3r::GUI::itVolume, L, m_objects_model, Slic3r::GUI::Plater::show_illegal_characters_warning(), and update_name_in_model().

Here is the call graph for this function:

reorder_volumes_and_get_selection()

wxDataViewItemArray Slic3r::GUI::ObjectList::reorder_volumes_and_get_selection	(	int	obj_idx,
		std::function< bool(const ModelVolume *)>	add_to_selection = nullptr )

{
    wxDataViewItemArray items;
    if (obj_idx < 0 || obj_idx >= m_objects->size()) {
        return items;
    }
    ModelObject* object = (*m_objects)[obj_idx];
    if (object->volumes.size() <= 1)
        return items;
 
    object->sort_volumes(true);
    update_info_items(obj_idx, nullptr, true);
    items = add_volumes_to_object_in_list(obj_idx, std::move(add_to_selection));
 
    changed_object(obj_idx);
    return items;
}

References add_volumes_to_object_in_list(), changed_object(), m_objects, object(), Slic3r::ModelObject::sort_volumes(), and update_info_items().

Referenced by apply_volumes_order(), load_generic_subobject(), load_subobject(), paste_volumes_into_list(), and set_volume_type().

Here is the call graph for this function:

Here is the caller graph for this function:

select_all()

void Slic3r::GUI::ObjectList::select_all

(

)

{
    SelectAll();
    selection_changed();
}

References Slic3r::GUI::SelectAll, and selection_changed().

Here is the call graph for this function:

select_item() [1/3]

void Slic3r::GUI::ObjectList::select_item

(

const ObjectVolumeID &

ov_id

)

{
    std::vector<ObjectVolumeID> ov_ids;
    ov_ids.push_back(ov_id);
    select_items(ov_ids);
}

References select_items().

Here is the call graph for this function:

select_item() [2/3]

void Slic3r::GUI::ObjectList::select_item

(

const wxDataViewItem &

item

)

{
    if (! item.IsOk()) { return; }
 
    m_prevent_list_events = true;
 
    UnselectAll();
    Select(item);
    part_selection_changed();
 
    m_prevent_list_events = false;
}

References m_prevent_list_events, and part_selection_changed().

Referenced by add_layer_range_after_current(), boolean(), decrease_object_instances(), del_layer_range(), delete_instance_from_list(), delete_object_from_list(), delete_object_from_list(), delete_volume_from_list(), edit_layer_range(), increase_object_instances(), layers_editing(), load_generic_subobject(), merge(), OnDrop(), paste_layers_into_list(), remove(), selected_object(), show_settings(), and update_settings_item_and_selection().

Here is the call graph for this function:

Here is the caller graph for this function:

select_item() [3/3]

void Slic3r::GUI::ObjectList::select_item

(

std::function< wxDataViewItem()>

get_item

)

{
    if (!get_item)
        return;
 
    m_prevent_list_events = true;
    m_prevent_list_manipulation = true;
 
    wxDataViewItem item = get_item();
    if (item.IsOk()) {
        UnselectAll();
        Select(item);
        part_selection_changed();
    }
 
    m_prevent_list_manipulation = false;
    m_prevent_list_events = false;
}

References m_prevent_list_events, m_prevent_list_manipulation, and part_selection_changed().

Here is the call graph for this function:

select_item_all_children()

void Slic3r::GUI::ObjectList::select_item_all_children

(

)

{
    if (wxGetApp().plater()  && !wxGetApp().plater()->canvas3D()->get_gizmos_manager().is_allow_select_all()) {
        return;
    }
    wxDataViewItemArray sels;
 
    // There is no selection before OR some object is selected   =>  select all objects
    if (!GetSelection() || m_objects_model->GetItemType(GetSelection()) == itObject) {
        for (size_t i = 0; i < m_objects->size(); i++)
            sels.Add(m_objects_model->GetItemById(i));
        m_selection_mode = smInstance;
    }
    else {
        const auto item = GetSelection();
        const ItemType item_type = m_objects_model->GetItemType(item);
        // Some volume/layer/instance is selected    =>  select all volumes/layers/instances inside the current object
        if (item_type & (itVolume | itInstance | itLayer))
            m_objects_model->GetChildren(m_objects_model->GetParent(item), sels);
 
        m_selection_mode = item_type&itVolume ? smVolume :
                           item_type&itLayer  ? smLayer  : smInstance;
    }
 
    SetSelections(sels);
    selection_changed();
}

References Slic3r::GUI::itInstance, Slic3r::GUI::itLayer, Slic3r::GUI::itObject, Slic3r::GUI::itVolume, m_objects, m_objects_model, m_selection_mode, Slic3r::GUI::plater(), selection_changed(), smInstance, smLayer, and smVolume.

Referenced by dispatch_shortcut().

Here is the call graph for this function:

Here is the caller graph for this function:

select_items() [1/2]

void Slic3r::GUI::ObjectList::select_items

(

const std::vector< ObjectVolumeID > &

ov_ids

)

{
    ModelObjectPtrs& objects = wxGetApp().model().objects;
 
    wxDataViewItemArray sel_items;
    for (auto ov_id : ov_ids) {
        if (ov_id.object == nullptr)
            continue;
 
        ModelObject* mo = ov_id.object;
        ModelVolume* mv = ov_id.volume;
 
        wxDataViewItem obj_item = m_objects_model->GetObjectItem(mo);
        if (mv != nullptr) {
            size_t vol_idx;
            for (vol_idx = 0; vol_idx < mo->volumes.size(); vol_idx++) {
                if (mo->volumes[vol_idx] == mv)
                    break;
            }
            assert(vol_idx < mo->volumes.size());
 
            wxDataViewItem vol_item = m_objects_model->GetVolumeItem(obj_item, vol_idx);
            if (vol_item.GetID() != nullptr) {
                sel_items.push_back(vol_item);
            }
            else {
                sel_items.push_back(obj_item);
            }
        }
        else {
            sel_items.push_back(obj_item);
        }
    }
 
    select_items(sel_items);
    selection_changed();
}

References m_objects_model, objects(), select_items(), selection_changed(), and Slic3r::ModelObject::volumes.

Here is the call graph for this function:

select_items() [2/2]

void Slic3r::GUI::ObjectList::select_items

(

const wxDataViewItemArray &

sels

)

{
    m_prevent_list_events = true;
    m_prevent_list_manipulation = true;
    m_last_selected_item = sels.empty() ? wxDataViewItem(nullptr) : sels.back();
 
    UnselectAll();
 
    if (!sels.empty()) {
        SetSelections(sels);
    }
    else {
        int curr_plate_idx = wxGetApp().plater()->get_partplate_list().get_curr_plate_index();
        on_plate_selected(curr_plate_idx);
    }
 
    part_selection_changed();
 
    m_prevent_list_manipulation = false;
    m_prevent_list_events = false;
}

References m_last_selected_item, m_prevent_list_events, m_prevent_list_manipulation, on_plate_selected(), and part_selection_changed().

Referenced by load_subobject(), paste_objects_into_list(), paste_volumes_into_list(), select_item(), select_items(), and update_selections().

Here is the call graph for this function:

Here is the caller graph for this function:

select_object_item()

void Slic3r::GUI::ObjectList::select_object_item

(

bool

is_msr_gizmo

)

{
    if (wxDataViewItem item = GetSelection()) {
        ItemType type = m_objects_model->GetItemType(item);
        bool is_volume_item = type == itVolume || (type == itSettings && m_objects_model->GetItemType(m_objects_model->GetParent(item)) == itVolume);
        if ((is_msr_gizmo && is_volume_item) || type == itObject)
            return;
 
        if (wxDataViewItem obj_item = m_objects_model->GetTopParent(item)) {
            m_prevent_list_events = true;
            UnselectAll();
            Select(obj_item);
            part_selection_changed();
            m_prevent_list_events = false;
        }
    }
}

References Slic3r::GUI::itObject, Slic3r::GUI::itSettings, Slic3r::GUI::itVolume, m_objects_model, m_prevent_list_events, and part_selection_changed().

Here is the call graph for this function:

selected_instances_of_same_object()

bool Slic3r::GUI::ObjectList::selected_instances_of_same_object

(

)

{
    wxDataViewItemArray sels;
    GetSelections(sels);
 
    const int obj_idx = m_objects_model->GetObjectIdByItem(sels.front());
 
    for (auto item : sels) {
        if (! (m_objects_model->GetItemType(item) & itInstance) ||
            obj_idx != m_objects_model->GetObjectIdByItem(item))
            return false;
    }
    return true;
}

References Slic3r::GUI::itInstance, and m_objects_model.

Referenced by OnBeginDrag(), and show_context_menu().

Here is the caller graph for this function:

selected_object()

void Slic3r::GUI::ObjectList::selected_object

(

ObjectDataViewModelNode *

item

)

{
    if (!item) {
        return;
    }
    this->SetFocus();
    select_item(wxDataViewItem(item));
    ensure_current_item_visible();
    selection_changed();
}

References ensure_current_item_visible(), select_item(), and selection_changed().

Here is the call graph for this function:

selection_changed()

void Slic3r::GUI::ObjectList::selection_changed

(

)

{
    if (wxGetApp().is_closing()) return;
    if (m_prevent_list_events) return;
 
    fix_multiselection_conflicts();
 
    fix_cut_selection();
 
    // update object selection on Plater
    if (!m_prevent_canvas_selection_update)
        update_selections_on_canvas();
 
    // to update the toolbar and info sizer
    if (!GetSelection() || m_objects_model->GetItemType(GetSelection()) == itObject) {
        auto event = SimpleEvent(EVT_OBJ_LIST_OBJECT_SELECT);
        event.SetEventObject(this);
        wxPostEvent(this, event);
    }
 
    if (const wxDataViewItem item = GetSelection())
    {
        const ItemType type = m_objects_model->GetItemType(item);
        // to correct visual hints for layers editing on the Scene
        if (type & (itLayer|itLayerRoot)) {
            wxGetApp().obj_layers()->reset_selection();
 
            if (type & itLayerRoot)
                wxGetApp().plater()->canvas3D()->handle_sidebar_focus_event("", false);
            else {
                wxGetApp().obj_layers()->set_selectable_range(m_objects_model->GetLayerRangeByItem(item));
                wxGetApp().obj_layers()->update_scene_from_editor_selection();
            }
        }
    }
 
    part_selection_changed();
}

References fix_cut_selection(), fix_multiselection_conflicts(), Slic3r::GUI::itLayer, Slic3r::GUI::itLayerRoot, Slic3r::GUI::itObject, m_objects_model, m_prevent_canvas_selection_update, m_prevent_list_events, part_selection_changed(), and update_selections_on_canvas().

Referenced by ObjectList(), add_object_to_list(), increase_object_instances(), load_generic_subobject(), load_subobject(), paste_layers_into_list(), paste_objects_into_list(), paste_volumes_into_list(), select_all(), select_item_all_children(), select_items(), and selected_object().

Here is the call graph for this function:

Here is the caller graph for this function:

set_color_paint_hidden()

void Slic3r::GUI::ObjectList::set_color_paint_hidden

(

const bool

hide

)

const

{
    GetColumn(colColorPaint)->SetHidden(hide);
    update_name_column_width();
}

References Slic3r::GUI::colColorPaint, and update_name_column_width().

Referenced by update_info_items().

Here is the call graph for this function:

Here is the caller graph for this function:

set_extruder_for_selected_items()

void Slic3r::GUI::ObjectList::set_extruder_for_selected_items

(

const int

extruder

)

{
    // BBS: check extruder id
    std::vector<std::string> colors = wxGetApp().plater()->get_extruder_colors_from_plater_config();
    if (extruder > colors.size())
        return;
 
    wxDataViewItemArray sels;
    GetSelections(sels);
 
    if (sels.empty())
        return;
 
    take_snapshot(_u8L("Change Filaments"));
 
    for (const wxDataViewItem& sel_item : sels)
    {
        /* We can change extruder for Object/Volume only.
         * So, if Instance is selected, get its Object item and change it
         */
        ItemType sel_item_type = m_objects_model->GetItemType(sel_item);
        // ORCA: Fix crash when setting filament for instance (item was used uninitialized)
        wxDataViewItem item = (sel_item_type & itInstance) ? m_objects_model->GetObject(sel_item) : sel_item;
        ItemType type = m_objects_model->GetItemType(item);
        if (type & itVolume) {
            const int obj_idx = m_objects_model->GetObjectIdByItem(item);
            int vol_idx = m_objects_model->GetVolumeIdByItem(item);
            vol_idx     = m_objects_model->get_real_volume_index_in_3d(obj_idx, vol_idx);
            if ((obj_idx < m_objects->size()) && (obj_idx < (*m_objects)[obj_idx]->volumes.size())) {
                auto volume_type = (*m_objects)[obj_idx]->volumes[vol_idx]->type();
                if (volume_type != ModelVolumeType::MODEL_PART && volume_type != ModelVolumeType::PARAMETER_MODIFIER)
                    continue;
            }
        }
 
        if (type & itLayerRoot)
            continue;
 
        // BBS: handle extruder 0 for part, use it's parent extruder
        int new_extruder = extruder;
        if (extruder == 0) {
            if (type & itObject) {
                new_extruder = 1;
            }
            else if ((type & itVolume) && (m_objects_model->GetVolumeType(sel_item) == ModelVolumeType::MODEL_PART)) {
                new_extruder = m_objects_model->GetExtruderNumber(m_objects_model->GetParent(sel_item));
            }
        }
 
        if (type & itInfo && m_objects_model->GetInfoItemType(item) == InfoItemType::CutConnectors) {
            const int obj_idx = m_objects_model->GetObjectIdByItem(item);
            for (size_t i = 0; i < (*m_objects)[obj_idx]->volumes.size(); i++) {
                auto mv = (*m_objects)[obj_idx]->volumes[i];
                if (mv->is_cut_connector()) {
                    ModelConfig &config = mv->config;
                    if (config.has("extruder"))
                        config.set("extruder", new_extruder);
                    else
                        config.set_key_value("extruder", new ConfigOptionInt(new_extruder));
                }
            }
        } else {
            ModelConfig &config = get_item_config(item);
            if (config.has("extruder"))
                config.set("extruder", new_extruder);
            else
                config.set_key_value("extruder", new ConfigOptionInt(new_extruder));
        }
 
        // for object, clear all its part volume's extruder config
        if (type & itObject) {
            ObjectDataViewModelNode* node = (ObjectDataViewModelNode*)item.GetID();
            for (ModelVolume* mv : node->m_model_object->volumes) {
                if (mv->type() == ModelVolumeType::MODEL_PART && mv->config.has("extruder"))
                    mv->config.erase("extruder");
            }
        }
 
        const wxString extruder_str = wxString::Format("%d", new_extruder);
        m_objects_model->SetExtruder(extruder_str, item);
    }
 
    // update scene
    wxGetApp().plater()->update();
 
    // BBS: update extruder/filament column
    Refresh();
}

References _u8L, config(), Slic3r::ModelVolume::config, Slic3r::GUI::CutConnectors, Slic3r::ModelConfig::erase(), get_item_config(), Slic3r::ModelConfig::has(), Slic3r::GUI::itInfo, Slic3r::GUI::itInstance, Slic3r::GUI::itLayerRoot, Slic3r::GUI::itObject, Slic3r::GUI::itVolume, Slic3r::GUI::ObjectDataViewModelNode::m_model_object, m_objects, m_objects_model, Slic3r::MODEL_PART, Slic3r::PARAMETER_MODIFIER, Slic3r::GUI::take_snapshot(), Slic3r::ModelVolume::type(), and Slic3r::ModelObject::volumes.

Referenced by ObjectList(), and key_event().

Here is the call graph for this function:

Here is the caller graph for this function:

set_filament_column_hidden()

void Slic3r::GUI::ObjectList::set_filament_column_hidden

(

const bool

hide

)

const

{
    GetColumn(colFilament)->SetHidden(hide);
    update_name_column_width();
}

References Slic3r::GUI::colFilament, and update_name_column_width().

Referenced by update_objects_list_filament_column(), and update_objects_list_filament_column_when_delete_filament().

Here is the call graph for this function:

Here is the caller graph for this function:

set_min_height()

void Slic3r::GUI::ObjectList::set_min_height

(

)

{
    // BBS
#if 0
    if (m_items_count == size_t(-1))
        m_items_count = 7;
    int list_min_height = lround(2.25 * (m_items_count + 1) * wxGetApp().em_unit()); // +1 is for height of control header
    this->SetMinSize(wxSize(1, list_min_height));
#endif
}

References em_unit(), and m_items_count.

Referenced by msw_rescale(), and update_min_height().

Here is the call graph for this function:

Here is the caller graph for this function:

set_selected_layers_range_idx()

void Slic3r::GUI::ObjectList::set_selected_layers_range_idx ( const int range_idx )

inline

{ m_selected_layers_range_idx = range_idx; }

References m_selected_layers_range_idx.

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

Here is the caller graph for this function:

set_selection_mode()

void Slic3r::GUI::ObjectList::set_selection_mode ( SELECTION_MODE mode )

inline

{ m_selection_mode = mode; }

References m_selection_mode.

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

Here is the caller graph for this function:

set_sinking_hidden()

void Slic3r::GUI::GUI::ObjectList::set_sinking_hidden

(

const bool

hide

)

const

{
    GetColumn(colSinking)->SetHidden(hide);
    update_name_column_width();
}

References Slic3r::GUI::colSinking, and update_name_column_width().

Referenced by update_info_items().

Here is the call graph for this function:

Here is the caller graph for this function:

set_support_paint_hidden()

void Slic3r::GUI::ObjectList::set_support_paint_hidden

(

const bool

hide

)

const

{
    GetColumn(colSupportPaint)->SetHidden(hide);
    update_name_column_width();
}

References Slic3r::GUI::colSupportPaint, and update_name_column_width().

Referenced by update_info_items().

Here is the call graph for this function:

Here is the caller graph for this function:

set_tooltip_for_item()

void Slic3r::GUI::ObjectList::set_tooltip_for_item

(

const wxPoint &

pt

)

{
    wxDataViewItem item;
    wxDataViewColumn* col;
    HitTest(pt, item, col);
 
    /* GetMainWindow() return window, associated with wxDataViewCtrl.
     * And for this window we should to set tooltips.
     * Just this->SetToolTip(tooltip) => has no effect.
     */
 
    if (!item || GetSelectedItemsCount() > 1)
    {
        GetMainWindow()->SetToolTip(""); // hide tooltip
        return;
    }
 
    wxString tooltip = "";
    ObjectDataViewModelNode* node = (ObjectDataViewModelNode*)item.GetID();
 
    if (col->GetModelColumn() == (unsigned int)colEditing) {
        if (node->IsActionEnabled())
#ifdef __WXOSX__
            tooltip = _(L("Right click the icon to drop the object settings"));
#else
            tooltip = _(L("Click the icon to reset all settings of the object"));
#endif //__WXMSW__
    }
    else if (col->GetModelColumn() == (unsigned int)colPrint)
#ifdef __WXOSX__
        tooltip = _(L("Right click the icon to drop the object printable property"));
#else
        tooltip = _(L("Click the icon to toggle printable properties of the object"));
#endif //__WXMSW__
    // BBS
    else if (col->GetModelColumn() == (unsigned int)colSupportPaint) {
        if (node->HasSupportPainting())
            tooltip = _(L("Click the icon to edit support painting of the object"));
 
    }
    else if (col->GetModelColumn() == (unsigned int)colColorPaint) {
        if (node->HasColorPainting())
            tooltip = _(L("Click the icon to edit color painting for the object"));
    }
    else if (col->GetModelColumn() == (unsigned int)colSinking) {
        if (node->HasSinking())
            tooltip = _(L("Click the icon to shift this object to the bed"));
    }
    else if (col->GetModelColumn() == (unsigned int)colName && (pt.x >= 2 * wxGetApp().em_unit() && pt.x <= 4 * wxGetApp().em_unit()))
    {
        if (const ItemType type = m_objects_model->GetItemType(item);
            type & (itObject | itVolume)) {
            int obj_idx = m_objects_model->GetObjectIdByItem(item);
            int vol_idx = type & itVolume ? m_objects_model->GetVolumeIdByItem(item) : -1;
            tooltip = get_mesh_errors_info(obj_idx, vol_idx).tooltip;
        }
    }
 
    GetMainWindow()->SetToolTip(tooltip);
}

References _, Slic3r::GUI::colColorPaint, Slic3r::GUI::colEditing, Slic3r::GUI::colName, Slic3r::GUI::colPrint, Slic3r::GUI::colSinking, Slic3r::GUI::colSupportPaint, em_unit(), get_mesh_errors_info(), Slic3r::GUI::ObjectDataViewModelNode::HasColorPainting(), Slic3r::GUI::ObjectDataViewModelNode::HasSinking(), Slic3r::GUI::ObjectDataViewModelNode::HasSupportPainting(), Slic3r::GUI::ObjectDataViewModelNode::IsActionEnabled(), Slic3r::GUI::itObject, Slic3r::GUI::itVolume, L, m_objects_model, and Slic3r::GUI::MeshErrorsInfo::tooltip.

Referenced by ObjectList().

Here is the call graph for this function:

Here is the caller graph for this function:

set_variable_height_column_hidden()

void Slic3r::GUI::ObjectList::set_variable_height_column_hidden

(

const bool

hide

)

const

{
    GetColumn(colHeight)->SetHidden(hide);
    update_name_column_width();
}

References Slic3r::GUI::colHeight, and update_name_column_width().

Referenced by delete_from_model_and_list(), and delete_from_model_and_list().

Here is the call graph for this function:

Here is the caller graph for this function:

set_volume_type()

void Slic3r::GUI::ObjectList::set_volume_type	(	ModelVolumeType	new_type,
		bool	preserve_ps_subtype = true )

{
    struct VolumeSelection {
        int          object_idx;
        ModelVolume* volume;
    };
 
    // --- Collect selected volumes from the object tree, falling back to the 3D canvas ---
    std::vector<VolumeSelection> volumes;
    auto add_volume = [&volumes](int obj_idx, ModelVolume* volume) {
        if (volume == nullptr)
            return;
        auto it = std::find_if(volumes.begin(), volumes.end(), [volume](const VolumeSelection& other) { return other.volume == volume; });
        if (it == volumes.end())
            volumes.push_back({ obj_idx, volume });
    };
 
    wxDataViewItemArray sels;
    GetSelections(sels);
    for (auto item : sels) {
        wxDataViewItem volume_item = item;
        ItemType       type        = m_objects_model->GetItemType(item);
        if (!(type & itVolume)) {
            if ((type & itSettings) && (m_objects_model->GetItemType(m_objects_model->GetParent(item)) & itVolume))
                volume_item = m_objects_model->GetParent(item);
            else
                continue;
        }
 
        const int obj_idx = m_objects_model->GetObjectIdByItem(volume_item);
        const int vol_idx = m_objects_model->GetVolumeIdByItem(volume_item);
        if (obj_idx < 0 || vol_idx < 0 || obj_idx >= m_objects->size())
            continue;
 
        const int real_idx = m_objects_model->get_real_volume_index_in_3d(obj_idx, vol_idx);
        if (real_idx < 0 || real_idx >= (*m_objects)[obj_idx]->volumes.size())
            continue;
 
        add_volume(obj_idx, (*m_objects)[obj_idx]->volumes[real_idx]);
    }
 
    auto collect_from_canvas = [&add_volume](GLCanvas3D* canvas) {
        if (canvas == nullptr)
            return;
        const Selection& selection = canvas->get_selection();
        for (auto idx : selection.get_volume_idxs()) {
            const GLVolume* gl_volume = selection.get_volume(idx);
            if (gl_volume == nullptr || gl_volume->object_idx() < 0)
                continue;
            ModelVolume* volume = get_model_volume(*gl_volume, selection.get_model()->objects);
            add_volume(gl_volume->object_idx(), volume);
        }
    };
 
    if (volumes.empty()) {
        collect_from_canvas(wxGetApp().plater()->canvas3D());
        if (volumes.empty()) {
            auto canvas_type = wxGetApp().plater()->get_current_canvas3D()->get_canvas_type();
            if (canvas_type == GLCanvas3D::ECanvasType::CanvasView3D && is_connectors_item_selected())
                collect_from_canvas(wxGetApp().plater()->get_view3D_canvas3D());
        }
        if (volumes.empty())
            return;
    }
 
    // Defense-in-depth safety net against issue #5070: SVG/text volumes carry emboss metadata
    // (text_configuration, emboss_shape) that only makes sense for Part / Negative Part / Modifier.
    // ModelVolume::set_type() does not clear that metadata, so converting such volumes to
    // Support Blocker / Support Enforcer leaves stale emboss state attached to a support volume
    // and historically crashed (originally fixed in the now-disabled change_part_type() by hiding
    // Support entries in the old choice dialog; the UI-side guard for the current submenu lives
    // in MenuFactory::append_menu_item_change_type, see #13120).
    // The same rationale applies to any Precise Seam subtype.
    // This block must never be reachable under a healthy UI; if it ever logs, the UI guard has
    // been bypassed (new entry point, refactor, plugin, etc.) and should be investigated.
    if (new_type == ModelVolumeType::SUPPORT_BLOCKER || new_type == ModelVolumeType::SUPPORT_ENFORCER
        || is_precise_seam(new_type)) {
        const bool has_text_or_svg = std::any_of(volumes.begin(), volumes.end(),
            [](const VolumeSelection& sel) { return sel.volume->is_svg() || sel.volume->is_text(); });
        if (has_text_or_svg) {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__
                << ": blocked attempt to set SUPPORT_BLOCKER/ENFORCER or Precise Seam on SVG/text volume; "
                << "UI guard should have prevented this -- possible regression in the Change Type menu";
            return;
        }
    }
 
    // --- Subtype preservation for the generic "Precise Seam" entry ---
    // The Change Type submenu uses PRECISE_SEAM_CENTER as the single "Precise Seam" entry
    // and calls with preserve_ps_subtype=true: volumes that are already Precise Seam keep
    // their subtype (LEFT/RIGHT/etc.); only non-PS volumes get converted to the default
    // CENTER subtype.
    //
    // The "Precise Seam Type" subtype submenu calls with preserve_ps_subtype=false: the
    // user explicitly picked CENTER and all selected PS volumes must be set to CENTER
    // verbatim (otherwise CENTER would become unreachable for mixed-subtype selections,
    // since preservation would keep every volume at its current subtype and any_diff would
    // be false — the reason for this two-parameter split).
    auto effective_new_type = [new_type, preserve_ps_subtype](const ModelVolume* v) -> ModelVolumeType {
        if (preserve_ps_subtype && new_type == ModelVolumeType::PRECISE_SEAM_CENTER && v->is_precise_seam())
            return v->type();
        return new_type;
    };
 
    // --- Any-change check using the effective target type ---
    const bool any_diff = std::any_of(volumes.begin(), volumes.end(),
        [&effective_new_type](const VolumeSelection& sel) {
            return sel.volume->type() != effective_new_type(sel.volume);
        });
 
    if (!any_diff)
        return;
 
    // --- Last-solid-part guard (pre-existing behavior) ---
    // When converting away from MODEL_PART, ensure at least one solid part remains per object.
    if (new_type != ModelVolumeType::MODEL_PART) {
        std::map<int, int> total_part_cnt;
        std::map<int, int> selected_part_cnt;
 
        for (const auto& sel : volumes) {
            if (total_part_cnt.find(sel.object_idx) == total_part_cnt.end()) {
                int count = 0;
                for (auto vol : (*m_objects)[sel.object_idx]->volumes)
                    if (vol->type() == ModelVolumeType::MODEL_PART)
                        ++count;
                total_part_cnt.emplace(sel.object_idx, count);
            }
            if (sel.volume->type() == ModelVolumeType::MODEL_PART)
                ++selected_part_cnt[sel.object_idx];
        }
 
        for (const auto& sel : selected_part_cnt) {
            auto it = total_part_cnt.find(sel.first);
            if (it != total_part_cnt.end() && it->second > 0 && sel.second == it->second) {
                Slic3r::GUI::show_error(nullptr, _(L("The type of the last solid object part cannot be changed.")));
                return;
            }
        }
    }
 
    take_snapshot(_u8L("Change part type"));
 
    // --- Apply type changes with Precise Seam group-aware repositioning ---
    // Note: `changed_volumes` / `touched_objects` track every processed volume, including
    // subtype-preservation no-ops. Tracking no-ops is intentional — it ensures such
    // volumes remain selected after the post-apply rebuild. Without that, a cross-object
    // mixed selection like [Part, PS_LEFT] clicking "Change type → Precise Seam" would
    // silently deselect the preserved PS_LEFT: only the Part's object would enter
    // touched_objects, and the final SetSelections(new_selection) would drop PS_LEFT.
    std::set<const ModelVolume*> changed_volumes;
    std::set<int>                touched_objects;
    for (const auto& sel : volumes) {
        const ModelVolumeType target   = effective_new_type(sel.volume);
        const ModelVolumeType old_type = sel.volume->type();
 
        // Record the volume for reselection before the no-op short-circuit (see comment above).
        changed_volumes.insert(sel.volume);
        touched_objects.insert(sel.object_idx);
 
        if (old_type == target)
            continue; // subtype-preservation no-op — nothing to write/move
 
        sel.volume->set_type(target);
 
        // If the change crosses a PS group boundary, move the volume to the end of volumes[]
        // so the stable sort in reorder_volumes_and_get_selection() places it at the end of
        // its new group (see precise_seam_group_changed() for details).
        if (precise_seam_group_changed(old_type, target))
            move_volume_to_end((*m_objects)[sel.object_idx], sel.volume);
    }
 
    // --- Rebuild selection to follow the changed volumes ---
    wxDataViewItemArray new_selection;
    for (int obj_idx : touched_objects) {
        wxDataViewItemArray sel_items = reorder_volumes_and_get_selection(obj_idx, [&changed_volumes](const ModelVolume* volume) {
            return changed_volumes.find(volume) != changed_volumes.end();
        });
        for (const auto& item : sel_items)
            new_selection.push_back(item);
    }
 
    if (!new_selection.IsEmpty()) {
        m_prevent_list_events = true;
        UnselectAll();
        SetSelections(new_selection);
        m_prevent_list_events = false;
    }
}

References _, _u8L, Slic3r::GUI::GLCanvas3D::CanvasView3D, count, Slic3r::GUI::Selection::get_model(), Slic3r::GUI::get_model_volume(), Slic3r::GUI::Selection::get_volume(), Slic3r::GUI::Selection::get_volume_idxs(), is_connectors_item_selected(), Slic3r::is_precise_seam(), Slic3r::GUI::itSettings, Slic3r::GUI::itVolume, L, m_objects, m_objects_model, m_prevent_list_events, Slic3r::MODEL_PART, Slic3r::GUI::move_volume_to_end(), Slic3r::GLVolume::object_idx(), Slic3r::Model::objects, Slic3r::GUI::plater(), Slic3r::PRECISE_SEAM_CENTER, Slic3r::GUI::precise_seam_group_changed(), reorder_volumes_and_get_selection(), Slic3r::GUI::show_error(), Slic3r::SUPPORT_BLOCKER, Slic3r::SUPPORT_ENFORCER, and Slic3r::GUI::take_snapshot().

Here is the call graph for this function:

show_context_menu()

void Slic3r::GUI::ObjectList::show_context_menu

(

const bool

evt_context_menu

)

{
    // BBS Disable menu popup if current canvas is Preview
    if (wxGetApp().plater()->get_current_canvas3D()->get_canvas_type() == GLCanvas3D::ECanvasType::CanvasPreview)
        return;
 
    wxMenu* menu {nullptr};
    Plater* plater = wxGetApp().plater();
 
    if (multiple_selection())
    {
        if (selected_instances_of_same_object())
            menu = plater->instance_menu();
        else
            menu = plater->multi_selection_menu();
    }
    else {
        const auto item = GetSelection();
        if (item)
        {
            const ItemType type = m_objects_model->GetItemType(item);
            if (!(type & (itPlate | itObject | itVolume | itInstance)))
                return;
            if (type & itVolume) {
                int obj_idx, vol_idx;
                get_selected_item_indexes(obj_idx, vol_idx, item);
                if (obj_idx < 0 || vol_idx < 0)
                    return;
                const ModelVolume *volume = object(obj_idx)->volumes[vol_idx];
 
                menu = volume->is_text() ? plater->text_part_menu() :
      volume->is_svg() ? plater->svg_part_menu() : // ORCA fixes missing "Edit SVG" item for Add/Negative/Modifier SVG objects in object list
                    plater->part_menu();
            }
            else
                menu =  type & itPlate                                              ? plater->plate_menu() :
                        type & itInstance                                           ? plater->instance_menu() :
                        printer_technology() == ptFFF                               ? plater->object_menu() : plater->sla_object_menu();
            plater->SetPlateIndexByRightMenuInLeftUI(-1);
            if (type & itPlate) {
                int            plate_idx = -1;
                const ItemType type0      = m_objects_model->GetItemType(item, plate_idx);
                if (plate_idx >= 0) { 
                    plater->SetPlateIndexByRightMenuInLeftUI(plate_idx);
                }
            }
        }
        else if (evt_context_menu)
            menu = plater->default_menu();
    }
 
    if (menu)
        plater->PopupMenu(menu);
}

References Slic3r::GUI::GLCanvas3D::CanvasPreview, get_selected_item_indexes(), Slic3r::ModelVolume::is_svg(), Slic3r::ModelVolume::is_text(), Slic3r::GUI::itInstance, Slic3r::GUI::itObject, Slic3r::GUI::itPlate, Slic3r::GUI::itVolume, m_objects_model, multiple_selection(), object(), Slic3r::GUI::plater(), Slic3r::GUI::printer_technology(), Slic3r::ptFFF, selected_instances_of_same_object(), and Slic3r::ModelObject::volumes.

Referenced by list_manipulation().

Here is the call graph for this function:

Here is the caller graph for this function:

show_settings()

void Slic3r::GUI::ObjectList::show_settings

(

const wxDataViewItem

settings_item

)

{
    if (!settings_item)
        return;
 
    select_item(settings_item);
 
    // update object selection on Plater
    if (!m_prevent_canvas_selection_update)
        update_selections_on_canvas();
}

References m_prevent_canvas_selection_update, select_item(), and update_selections_on_canvas().

Referenced by add_category_to_settings_from_frequent(), and add_category_to_settings_from_selection().

Here is the call graph for this function:

Here is the caller graph for this function:

simplify()

void Slic3r::GUI::ObjectList::simplify

(

)

{
    auto plater = wxGetApp().plater();
    GLGizmosManager& gizmos_mgr = plater->get_view3D_canvas3D()->get_gizmos_manager();
 
    // Do not simplify when a gizmo is open. There might be issues with updates
    // and what is worse, the snapshot time would refer to the internal stack.
    if (! gizmos_mgr.check_gizmos_closed_except(GLGizmosManager::EType::Simplify))
        return;
 
    if (gizmos_mgr.get_current_type() == GLGizmosManager::Simplify) {
        // close first
        gizmos_mgr.open_gizmo(GLGizmosManager::EType::Simplify);
    }
    gizmos_mgr.open_gizmo(GLGizmosManager::EType::Simplify);
}

References Slic3r::GUI::GLGizmosManager::check_gizmos_closed_except(), Slic3r::GUI::GLGizmosManager::get_current_type(), Slic3r::GUI::GLGizmosManager::open_gizmo(), Slic3r::GUI::plater(), and Slic3r::GUI::GLGizmosManager::Simplify.

Here is the call graph for this function:

smooth_mesh()

void Slic3r::GUI::GUI::ObjectList::smooth_mesh

(

)

{
    wxBusyCursor cursor;
    auto plater = wxGetApp().plater();
    if (!plater) { return; }
    plater->take_snapshot("smooth_mesh");
    std::vector<int> obj_idxs, vol_idxs;
    get_selection_indexes(obj_idxs, vol_idxs);
    auto object_idx = obj_idxs.front();
    ModelObject *obj{nullptr};
    auto show_warning_dlg = [](int cur_face_count,std::string name,bool is_part) {
        int limit_face_count = 1000000;
        if (cur_face_count > limit_face_count) {
            auto name_str = wxString::FromUTF8(name);
            auto content = wxString::Format(_L("\"%s\" will exceed 1 million faces after this subdivision, which may increase slicing time. Do you want to continue?"), name_str);
            WarningDialog dlg(static_cast<wxWindow *>(wxGetApp().mainframe), (is_part ? _L("Part") : _L("Object")) + " " + content, wxEmptyString, wxYES_NO);
            if (dlg.ShowModal() == wxID_NO) {
                return true;
            }
            return false;
        }
        return false;
    };
    auto show_smooth_mesh_error_dlg = [](std::string name) {
        auto name_str = wxString::FromUTF8(name);
        auto content  = wxString::Format(_L("\"%s\" part's mesh contains errors. Please repair it first."), name_str);
        WarningDialog dlg(static_cast<wxWindow *>(wxGetApp().mainframe), content, wxEmptyString, wxOK);
        dlg.ShowModal();
    };
    const bool keep_painting = GUI::wxGetApp().app_config->get_bool("keep_painting");
    bool has_show_smooth_mesh_error_dlg = false;
    if (vol_idxs.empty()) {
        obj        = object(object_idx);
        auto             future_face_count = static_cast<int>(obj->facets_count()) * 4;
        if (show_warning_dlg(future_face_count, obj->name,false)) {
            return;
        }
        for (auto mv : obj->volumes) {
            bool ok;
            auto result_mesh = TriangleMeshDeal::smooth_triangle_mesh(mv->mesh(), ok);
            if (ok) {
                const std::optional<TriangleSelector::SavedPainting> saved_painting = keep_painting ?
                                                                                          mv->save_painting() :
                                                                                          std::optional<TriangleSelector::SavedPainting>{};
                mv->set_mesh(result_mesh);
                mv->restore_painting(saved_painting);
                mv->calculate_convex_hull();
                mv->invalidate_convex_hull_2d();
                mv->set_new_unique_id();
            } else {
                if (!has_show_smooth_mesh_error_dlg) {
                    show_smooth_mesh_error_dlg(mv->name);
                    has_show_smooth_mesh_error_dlg = true;
                }
            }
        }
        obj->invalidate_bounding_box();
        obj->ensure_on_bed();
        plater->changed_mesh(object_idx);
    } else {
        obj = object(obj_idxs.front());
        for (int vol_idx : vol_idxs) {
            auto mv = obj->volumes[vol_idx];
            auto future_face_count = static_cast<int>(mv->mesh().facets_count()) * 4;
            if (show_warning_dlg(future_face_count, mv->name,true)) {
                return;
            }
            bool ok;
            auto result_mesh = TriangleMeshDeal::smooth_triangle_mesh(mv->mesh(),ok);
            if (ok) {
                const std::optional<TriangleSelector::SavedPainting> saved_painting = keep_painting ?
                                                                                          mv->save_painting() :
                                                                                          std::optional<TriangleSelector::SavedPainting>{};
                mv->set_mesh(result_mesh);
                mv->restore_painting(saved_painting);
                mv->calculate_convex_hull();
                mv->invalidate_convex_hull_2d();
                mv->set_new_unique_id();
            } else {
                if (!has_show_smooth_mesh_error_dlg) {
                    show_smooth_mesh_error_dlg(mv->name);
                    has_show_smooth_mesh_error_dlg = true;
                }
            }
        }
    }
    if (obj) {
        obj->invalidate_bounding_box();
        obj->ensure_on_bed();
        plater->changed_mesh(object_idx);
    }
}

References _L, Slic3r::ModelObject::ensure_on_bed(), Slic3r::ModelObject::facets_count(), get_selection_indexes(), Slic3r::ModelObject::invalidate_bounding_box(), Slic3r::ModelObject::name, object(), Slic3r::GUI::plater(), Slic3r::GUI::DPIAware< P >::ShowModal(), Slic3r::TriangleMeshDeal::smooth_triangle_mesh(), and Slic3r::ModelObject::volumes.

Here is the call graph for this function:

split()

void Slic3r::GUI::ObjectList::split

(

)

{
    const auto item = GetSelection();
    const int obj_idx = get_selected_obj_idx();
    if (!item || obj_idx < 0)
        return;
 
    ModelVolume* volume;
    if (!get_volume_by_item(item, volume)) return;
    DynamicPrintConfig& config = printer_config();
    // BBS
    const ConfigOptionStrings* filament_colors = config.option<ConfigOptionStrings>("filament_colour", false);
    const auto filament_cnt = (filament_colors == nullptr) ? size_t(1) : filament_colors->size();
    if (!volume->is_splittable()) {
        wxMessageBox(_(L("The target object contains only one part and can not be split.")));
        return;
    }
 
    take_snapshot(_u8L("Split to parts"));
 
    volume->split(filament_cnt, wxGetApp().app_config->get_bool("keep_painting"));
 
    wxBusyCursor wait;
 
    auto model_object = (*m_objects)[obj_idx];
 
    auto parent = m_objects_model->GetObject(item);
    if (parent)
        m_objects_model->DeleteVolumeChildren(parent);
    else
        parent = item;
 
    for (const ModelVolume* volume : model_object->volumes) {
        const wxDataViewItem& vol_item = m_objects_model->AddVolumeChild(parent, from_u8(volume->name),
            volume->type(),// is_modifier() ? ModelVolumeType::PARAMETER_MODIFIER : ModelVolumeType::MODEL_PART,
            volume->is_text(),
            volume->is_svg(),
      get_warning_icon_name(volume->mesh().stats()),
            volume->config.has("extruder") ? volume->config.extruder() : 0,
            false);
        // add settings to the part, if it has those
        add_settings_item(vol_item, &volume->config.get());
    }
 
    model_object->input_file.clear();
 
    if (parent == item)
        Expand(parent);
 
    changed_object(obj_idx);
 
    //BBS: notify partplate the modify
    notify_instance_updated(obj_idx);
 
    update_info_items(obj_idx);
}

References _, _u8L, add_settings_item(), changed_object(), config(), Slic3r::ModelVolume::config, Slic3r::ModelConfig::extruder(), Slic3r::GUI::from_u8(), Slic3r::ModelConfig::get(), get_selected_obj_idx(), get_volume_by_item(), Slic3r::GUI::get_warning_icon_name(), Slic3r::ModelConfig::has(), Slic3r::ModelVolume::is_splittable(), Slic3r::ModelVolume::is_svg(), Slic3r::ModelVolume::is_text(), L, m_objects_model, Slic3r::ModelVolume::mesh(), Slic3r::ModelVolume::name, notify_instance_updated(), Slic3r::GUI::printer_config(), Slic3r::ConfigOptionVector< T >::size(), Slic3r::ModelVolume::split(), Slic3r::TriangleMesh::stats(), Slic3r::GUI::take_snapshot(), Slic3r::ModelVolume::type(), and update_info_items().

Here is the call graph for this function:

split_instances()

void Slic3r::GUI::ObjectList::split_instances

(

)

{
    const Selection& selection = scene_selection();
    const int obj_idx = selection.get_object_idx();
    if (obj_idx == -1)
        return;
 
    Plater::TakeSnapshot snapshot(wxGetApp().plater(), _u8L("Instances to Separated Objects"));
 
    if (selection.is_single_full_object())
    {
        instances_to_separated_objects(obj_idx);
        return;
    }
 
    const int inst_idx = selection.get_instance_idx();
    const std::set<int> inst_idxs = inst_idx < 0 ?
                                    selection.get_instance_idxs() :
                                    std::set<int>{ inst_idx };
 
    instances_to_separated_object(obj_idx, inst_idxs);
}

References _u8L, Slic3r::GUI::Selection::get_instance_idx(), Slic3r::GUI::Selection::get_instance_idxs(), Slic3r::GUI::Selection::get_object_idx(), instances_to_separated_object(), instances_to_separated_objects(), Slic3r::GUI::Selection::is_single_full_object(), Slic3r::GUI::plater(), and Slic3r::GUI::scene_selection().

Here is the call graph for this function:

switch_to_object_process()

void Slic3r::GUI::ObjectList::switch_to_object_process

(

)

{
    wxGetApp().params_panel()->switch_to_object(true);
 
    // Show Dialog
    if (wxGetApp().app_config->get("do_not_show_object_process_tips").empty()) {
        TipsDialog dlg(wxGetApp().mainframe, _L("Edit Process Settings"), _L("Switch to per-object setting mode to edit process settings of selected objects."), "do_not_show_object_process_tips");
        dlg.ShowModal();
    }
}

References _L, and Slic3r::GUI::DPIAware< P >::ShowModal().

Here is the call graph for this function:

sys_color_changed()

void Slic3r::GUI::ObjectList::sys_color_changed

(

)

{
    wxGetApp().UpdateDVCDarkUI(this, true);
    
    msw_rescale();
 
    if (m_objects_model) { m_objects_model->sys_color_changed(); }
}

References m_objects_model, and msw_rescale().

Referenced by Slic3r::GUI::Sidebar::sys_color_changed().

Here is the call graph for this function:

Here is the caller graph for this function:

toggle_auto_drop()

void Slic3r::GUI::ObjectList::toggle_auto_drop

(

)

{
    wxDataViewItemArray sels;
    GetSelections(sels);
    if (sels.IsEmpty())
        return;
 
    for (auto item : sels) {
        ItemType type = m_objects_model->GetItemType(item);
        if (!(type & (itObject | itInstance)))
            return;
    }
 
    const bool current_auto_drop = wxGetApp().plater()->get_selection().get_auto_drop();
 
    take_snapshot("");
 
    std::vector<size_t> obj_idxs;
    for (auto item : sels) {
        int obj_idx      = m_objects_model->GetObjectIdByItem(item);
        ModelObject* obj = object(obj_idx);
 
        obj_idxs.emplace_back(static_cast<size_t>(obj_idx));
 
        // auto_drop is shared by all instances of an object.
        obj->auto_drop = !current_auto_drop;
        if (current_auto_drop == false)
            obj->ensure_on_bed();
    }
 
    sort(obj_idxs.begin(), obj_idxs.end());
    obj_idxs.erase(unique(obj_idxs.begin(), obj_idxs.end()), obj_idxs.end());
 
    // update scene
    wxGetApp().plater()->update();
    wxGetApp().plater()->reload_paint_after_background_process_apply();
}

References Slic3r::ModelObject::auto_drop, Slic3r::ModelObject::ensure_on_bed(), Slic3r::GUI::itInstance, Slic3r::GUI::itObject, m_objects_model, object(), and Slic3r::GUI::take_snapshot().

Referenced by dispatch_shortcut().

Here is the call graph for this function:

Here is the caller graph for this function:

toggle_printable_state()

void Slic3r::GUI::ObjectList::toggle_printable_state

(

)

{
    wxDataViewItemArray sels;
    GetSelections(sels);
    if (sels.IsEmpty())
        return;
 
    wxDataViewItem frst_item = sels[0];
 
    ItemType type = m_objects_model->GetItemType(frst_item);
    if (!(type & (itObject | itInstance)))
        return;
 
 
    int obj_idx = m_objects_model->GetObjectIdByItem(frst_item);
    int inst_idx = type == itObject ? 0 : m_objects_model->GetInstanceIdByItem(frst_item);
    bool printable = !object(obj_idx)->instances[inst_idx]->printable;
 
    // BBS: remove snapshot name "Set Printable group", "Set Unprintable group", "Set Printable"...
    take_snapshot("");
 
    std::vector<size_t> obj_idxs;
    for (auto item : sels)
    {
        type = m_objects_model->GetItemType(item);
        if (!(type & (itObject | itInstance)))
            continue;
 
        obj_idx = m_objects_model->GetObjectIdByItem(item);
        ModelObject* obj = object(obj_idx);
 
        obj_idxs.emplace_back(static_cast<size_t>(obj_idx));
 
        // set printable value for selected instance/instances in object
        if (type == itInstance) {
            inst_idx = m_objects_model->GetInstanceIdByItem(item);
            obj->instances[m_objects_model->GetInstanceIdByItem(item)]->printable = printable;
        }
        else
            for (auto inst : obj->instances)
                inst->printable = printable;
 
        // update printable state in ObjectList
        m_objects_model->SetObjectPrintableState(printable ? piPrintable : piUnprintable, item);
    }
 
    sort(obj_idxs.begin(), obj_idxs.end());
    obj_idxs.erase(unique(obj_idxs.begin(), obj_idxs.end()), obj_idxs.end());
 
    // update printable state on canvas
    wxGetApp().plater()->get_view3D_canvas3D()->update_instance_printable_state_for_objects(obj_idxs);
 
    // update scene
    wxGetApp().plater()->update();
    wxGetApp().plater()->reload_paint_after_background_process_apply();
}

References Slic3r::ModelObject::instances, Slic3r::GUI::itInstance, Slic3r::GUI::itObject, m_objects_model, object(), Slic3r::GUI::piPrintable, Slic3r::GUI::piUnprintable, and Slic3r::GUI::take_snapshot().

Referenced by dispatch_shortcut(), list_manipulation(), and OnEditingStarted().

Here is the call graph for this function:

Here is the caller graph for this function:

undo()

void Slic3r::GUI::ObjectList::undo

(

)

{
  wxGetApp().plater()->undo();
}

Referenced by dispatch_shortcut().

Here is the caller graph for this function:

unselect_objects()

void Slic3r::GUI::ObjectList::unselect_objects

(

)

{
    if (!GetSelection())
        return;
 
    m_prevent_list_events = true;
    UnselectAll();
    part_selection_changed();
    m_prevent_list_events = false;
}

References m_prevent_list_events, and part_selection_changed().

Referenced by Slic3r::GUI::Plater::priv::undo_redo_to(), and Slic3r::GUI::Sidebar::update_mode().

Here is the call graph for this function:

Here is the caller graph for this function:

update_after_undo_redo()

void Slic3r::GUI::ObjectList::update_after_undo_redo

(

)

{
    Plater::SuppressSnapshots suppress(wxGetApp().plater());
    //BBS: undo/redo will rebuild all the plates before
    //no need to notify instance to partplate
    reload_all_plates(false);
}

References Slic3r::GUI::plater(), and reload_all_plates().

Here is the call graph for this function:

update_and_show_object_settings_item()

void Slic3r::GUI::ObjectList::update_and_show_object_settings_item

(

)

{
    //const wxDataViewItem item = GetSelection();
    //if (!item) return;
 
    //const wxDataViewItem& obj_item = m_objects_model->IsSettingsItem(item) ? m_objects_model->GetParent(item) : item;
    //select_item([this, obj_item](){ return add_settings_item(obj_item, &get_item_config(obj_item).get()); });
    part_selection_changed();
}

References part_selection_changed().

Here is the call graph for this function:

update_filament_colors()

void Slic3r::GUI::ObjectList::update_filament_colors

(

)

{
    m_objects_model->UpdateColumValues(colFilament);
    // BBS: fix color not refresh
    Refresh();
}

References Slic3r::GUI::colFilament, and m_objects_model.

Referenced by Slic3r::GUI::Sidebar::sync_ams_list(), Slic3r::GUI::Sidebar::update_mixed_filament_list(), update_objects_list_filament_column(), and update_objects_list_filament_column_when_delete_filament().

Here is the caller graph for this function:

update_filament_in_config()

void Slic3r::GUI::ObjectList::update_filament_in_config

(

const wxDataViewItem &

item

)

{
    if (m_prevent_update_filament_in_config)
        return;
 
    ModelConfig* config = nullptr;
    const ItemType item_type = m_objects_model->GetItemType(item);
    if (item_type & itObject) {
        const int obj_idx = m_objects_model->GetIdByItem(item);
        config = &(*m_objects)[obj_idx]->config;
    }
    else {
        const int obj_idx = m_objects_model->GetIdByItem(m_objects_model->GetObject(item));
        if (item_type & itVolume){
             const int ui_volume_idx = m_objects_model->GetVolumeIdByItem(item);
             if (obj_idx < 0 || ui_volume_idx < 0)
                return;
             int volume_in3d_idx = m_objects_model->get_real_volume_index_in_3d(obj_idx,ui_volume_idx);
             config              = &(*m_objects)[obj_idx]->volumes[volume_in3d_idx]->config;
        }
        else if (item_type & itLayer)
            config = &get_item_config(item);
    }
 
    if (!config)
        return;
 
    m_config = config;
 
    take_snapshot(_u8L("Change Filament"));
 
    const int extruder = m_objects_model->GetExtruderNumber(item);
    m_config->set_key_value("extruder", new ConfigOptionInt(extruder));
 
    // BBS
    if (item_type & itObject) {
        const int obj_idx = m_objects_model->GetIdByItem(item);
        for (ModelVolume* mv : (*m_objects)[obj_idx]->volumes) {
            if (mv->config.has("extruder"))
                mv->config.erase("extruder");
        }
    }
 
    // update scene
    wxGetApp().plater()->update();
}

References _u8L, config(), get_item_config(), Slic3r::GUI::itLayer, Slic3r::GUI::itObject, Slic3r::GUI::itVolume, m_config, m_objects, m_objects_model, m_prevent_update_filament_in_config, and Slic3r::GUI::take_snapshot().

Referenced by extruder_editing(), and ItemValueChanged().

Here is the call graph for this function:

Here is the caller graph for this function:

update_filament_values_for_items()

void Slic3r::GUI::ObjectList::update_filament_values_for_items

(

const size_t

filaments_count

)

{
    for (size_t i = 0; i < m_objects->size(); ++i)
    {
        wxDataViewItem item = m_objects_model->GetItemById(i);
        if (!item) continue;
 
        auto object = (*m_objects)[i];
        wxString extruder;
        if (!object->config.has("extruder") || size_t(object->config.extruder()) > filaments_count) {
            extruder = "1";
            object->config.set_key_value("extruder", new ConfigOptionInt(1));
        }
        else {
            extruder = wxString::Format("%d", object->config.extruder());
        }
        m_objects_model->SetExtruder(extruder, item);
 
        static const char *keys[] = {"support_filament", "support_interface_filament"};
        for (auto key : keys)
            if (object->config.has(key) && object->config.opt_int(key) > filaments_count)
                object->config.erase(key);
 
        if (object->volumes.size() > 1) {
            for (size_t id = 0; id < object->volumes.size(); id++) {
                item = m_objects_model->GetItemByVolumeId(i, id);
                if (!item) continue;
                if (!object->volumes[id]->config.has("extruder") ||
                    size_t(object->volumes[id]->config.extruder()) > filaments_count) {
                    extruder = wxString::Format("%d", object->config.extruder());
                    // Clear the stale per-volume assignment so it falls back to the object's
                    // extruder; otherwise the out-of-range index survives. Ported from
                    // BambuStudio (STUDIO-15763).
                    object->volumes[id]->config.erase("extruder");
                }
                else {
                    extruder = wxString::Format("%d", object->volumes[id]->config.extruder());
                }
 
                m_objects_model->SetExtruder(extruder, item);
 
                for (auto key : keys)
                    if (object->volumes[id]->config.has(key) && object->volumes[id]->config.opt_int(key) > filaments_count)
                        object->volumes[id]->config.erase(key);
            }
        }
    }
 
    // BBS
    wxGetApp().plater()->update();
}

References Slic3r::GUI::filaments_count(), m_objects, m_objects_model, and object().

Referenced by update_objects_list_filament_column().

Here is the call graph for this function:

Here is the caller graph for this function:

update_filament_values_for_items_when_delete_filament()

void Slic3r::GUI::ObjectList::update_filament_values_for_items_when_delete_filament	(	const size_t	filament_id,
		const int	replace_id = -1 )

{
    int replace_filament_id = replace_id == -1 ? 1 : (replace_id + 1);
    for (size_t i = 0; i < m_objects->size(); ++i) {
        wxDataViewItem item = m_objects_model->GetItemById(i);
        if (!item)
            continue;
 
        auto     object = (*m_objects)[i];
        wxString extruder;
        if (!object->config.has("extruder")) {
            extruder = std::to_string(1);
            object->config.set_key_value("extruder", new ConfigOptionInt(1));
        }
        else if (size_t(object->config.extruder()) == filament_id + 1) {
            extruder = std::to_string(replace_filament_id);
            object->config.set_key_value("extruder", new ConfigOptionInt(replace_filament_id));
        } else {
            int new_extruder = object->config.extruder() > filament_id ? object->config.extruder() - 1 : object->config.extruder();
            extruder = wxString::Format("%d", new_extruder);
            object->config.set_key_value("extruder", new ConfigOptionInt(new_extruder));
        }
        m_objects_model->SetExtruder(extruder, item);
 
        static const char *keys[] = {"support_filament", "support_interface_filament"};
        for (auto key : keys) {
            if (object->config.has(key)) {
                if(object->config.opt_int(key) == filament_id + 1)
                    object->config.erase(key);
                else {
                    int new_value = object->config.opt_int(key) > filament_id ? object->config.opt_int(key) - 1 : object->config.opt_int(key);
                    object->config.set_key_value(key, new ConfigOptionInt(new_value));
                }
            }
        }
 
        //if (object->volumes.size() > 1) {
            for (size_t id = 0; id < object->volumes.size(); id++) {
                item = m_objects_model->GetItemByVolumeId(i, id);
                if (!item)
                    continue;
 
                for (auto key : keys) {
                    if (object->volumes[id]->config.has(key)) {
                        if (object->volumes[id]->config.opt_int(key) == filament_id + 1)
                            object->volumes[id]->config.erase(key);
                        else {
                            int new_value = object->volumes[id]->config.opt_int(key) > filament_id ? object->volumes[id]->config.opt_int(key) - 1 :
                                                                                                     object->volumes[id]->config.opt_int(key);
                            object->config.set_key_value(key, new ConfigOptionInt(new_value));
                        }
                    }
                }
 
                if (!object->volumes[id]->config.has("extruder")) {
                    continue;
                }
                else if (size_t(object->volumes[id]->config.extruder()) == filament_id + 1) {
                    object->volumes[id]->config.set_key_value("extruder", new ConfigOptionInt(replace_filament_id));
                } else {
                    int new_extruder = object->volumes[id]->config.extruder() > filament_id ? object->volumes[id]->config.extruder() - 1 : object->volumes[id]->config.extruder();
                    extruder = wxString::Format("%d", new_extruder);
                    object->volumes[id]->config.set_key_value("extruder", new ConfigOptionInt(new_extruder));
                }
 
                m_objects_model->SetExtruder(extruder, item);
            }
        //}
 
        item = m_objects_model->GetItemById(i);
        ObjectDataViewModelNode *object_node = static_cast<ObjectDataViewModelNode *>(item.GetID());
        if (object_node->GetChildCount() == 0)
            continue;
 
        // update height_range
        for (size_t i = 0; i < object_node->GetChildCount(); i++) {
            ObjectDataViewModelNode * layer_root_node = object_node->GetNthChild(i);
            if (layer_root_node->GetType() != ItemType::itLayerRoot)
                continue;
            for (size_t j = 0; j < layer_root_node->GetChildCount(); j++) {
                ObjectDataViewModelNode * layer_node = layer_root_node->GetNthChild(j);
                auto layer_item = wxDataViewItem((void *) layer_root_node->GetNthChild(j));
                if (!layer_item)
                    continue;
                auto l_iter = object->layer_config_ranges.find(layer_node->GetLayerRange());
                if (l_iter != object->layer_config_ranges.end()) {
                    auto& layer_range_item = *(l_iter);
                    if (layer_range_item.second.has("extruder") && layer_range_item.second.option("extruder")->getInt() == filament_id + 1) {
                        int new_extruder = replace_id == -1 ? 0 : (replace_id + 1);
                        extruder         = wxString::Format("%d", new_extruder);
                        layer_range_item.second.set("extruder", new_extruder);
                    } else {
                        int layer_filament_id = layer_range_item.second.option("extruder")->getInt();
                        int new_extruder      = layer_filament_id > filament_id ? layer_filament_id - 1 : layer_filament_id;
                        extruder              = wxString::Format("%d", new_extruder);
                        layer_range_item.second.set("extruder", new_extruder);
                    }
                    m_objects_model->SetExtruder(extruder, layer_item);
                }
            }
        }
    }
}

References Slic3r::GUI::ObjectDataViewModelNode::GetChildCount(), Slic3r::GUI::ObjectDataViewModelNode::GetLayerRange(), Slic3r::GUI::ObjectDataViewModelNode::GetNthChild(), Slic3r::GUI::ObjectDataViewModelNode::GetType(), Slic3r::GUI::itLayerRoot, m_objects, m_objects_model, and object().

Referenced by update_objects_list_filament_column_when_delete_filament().

Here is the call graph for this function:

Here is the caller graph for this function:

update_info_items()

void Slic3r::GUI::ObjectList::update_info_items	(	size_t	obj_idx,
		wxDataViewItemArray *	selections = nullptr,
		bool	added_object = false,
		bool	color_mode_changed = false )

{
    // BBS
    if (obj_idx >= m_objects->size())
        return;
 
    const ModelObject* model_object = (*m_objects)[obj_idx];
    wxDataViewItem item_obj = m_objects_model->GetItemById(obj_idx);
    assert(item_obj.IsOk());
 
    // Cut connectors
    {
        wxDataViewItem item = m_objects_model->GetInfoItemByType(item_obj, InfoItemType::CutConnectors);
        bool shows = item.IsOk();
        bool should_show = model_object->is_cut() && model_object->has_connectors() && model_object->volumes.size() > 1;
 
        if (!shows && should_show) {
            m_objects_model->AddInfoChild(item_obj, InfoItemType::CutConnectors);
            Expand(item_obj);
            if (added_object)
                wxGetApp().notification_manager()->push_updated_item_info_notification(InfoItemType::CutConnectors);
        } else if (shows && !should_show) {
            if (!selections) Unselect(item);
            m_objects_model->Delete(item);
            if (selections) {
                if (selections->Index(item) != wxNOT_FOUND) {
                    // If info item was deleted from the list,
                    // it's need to be deleted from selection array, if it was there
                    selections->Remove(item);
                    // Select item_obj, if info_item doesn't exist for item anymore, but was selected
                    if (selections->Index(item_obj) == wxNOT_FOUND) selections->Add(item_obj);
                }
            } else
                Select(item_obj);
        }
    }
 
    {
        ObjectDataViewModelNode* obj_node = static_cast<ObjectDataViewModelNode*>(item_obj.GetID());
        auto layer_data_count = model_object->layer_height_profile.get().size();
        update_variable_layer_obj_num(obj_node, layer_data_count);
        // If the length of layer_height_profile is greater than 4, variable layer height is applied
        m_objects_model->SetObjectVariableHeightState(layer_data_count > 4 ? hiVariable : hiUnVariable, item_obj);
    }
 
    {
        bool shows = m_objects_model->IsSupportPainted(item_obj);
        bool should_show = printer_technology() == ptFFF
            && std::any_of(model_object->volumes.begin(), model_object->volumes.end(),
                [](const ModelVolume* mv) {
                    return !mv->supported_facets.empty();
                });
        if (shows && !should_show) {
            m_objects_model->SetSupportPaintState(false, item_obj);
        }
        else if (!shows && should_show) {
            m_objects_model->SetSupportPaintState(true, item_obj);
        }
        if (color_mode_changed && shows) {
            m_objects_model->SetSupportPaintState(true, item_obj,true);
        }
    }
 
    {
        bool shows = m_objects_model->IsColorPainted(item_obj);
        bool should_show = printer_technology() == ptFFF
            && std::any_of(model_object->volumes.begin(), model_object->volumes.end(),
                [](const ModelVolume* mv) {
                    return !mv->mmu_segmentation_facets.empty();
                });
        if (shows && !should_show) {
            m_objects_model->SetColorPaintState(false, item_obj);
        }
        else if (!shows && should_show) {
            m_objects_model->SetColorPaintState(true, item_obj);
        }
        if (color_mode_changed && shows) {
            m_objects_model->SetColorPaintState(true, item_obj, true);
        }
    }
 
    {
        bool shows = m_objects_model->IsSinked(item_obj);
        bool should_show = printer_technology() == ptFFF
            && wxGetApp().plater()->canvas3D()->is_object_sinking(obj_idx);
        if (shows && !should_show) {
            m_objects_model->SetSinkState(false, item_obj);
        }
        else if (!shows && should_show) {
            m_objects_model->SetSinkState(true, item_obj);
        }
        if (color_mode_changed && shows) {
            m_objects_model->SetSinkState(true, item_obj, true);
        }
    }
 
    {
        bool shows = this->GetColumn(colSupportPaint)->IsShown();
        bool should_show = false;
        for (ModelObject* mo : *m_objects) {
            for (ModelVolume* mv : mo->volumes) {
                if (!mv->supported_facets.empty()) {
                    should_show = true;
                    break;
                }
            }
            if (should_show)
                break;
        }
 
        if (shows && !should_show) {
            this->set_support_paint_hidden(true);
        }
        else if (!shows && should_show) {
            this->set_support_paint_hidden(false);
        }
    }
 
    {
        bool shows = this->GetColumn(colColorPaint)->IsShown();
        bool should_show = false;
        for (ModelObject* mo : *m_objects) {
            for (ModelVolume* mv : mo->volumes) {
                if (!mv->mmu_segmentation_facets.empty()) {
                    should_show = true;
                    break;
                }
            }
            if (should_show)
                break;
        }
 
        if (shows && !should_show) {
            this->set_color_paint_hidden(true);
        }
        else if (!shows && should_show) {
            this->set_color_paint_hidden(false);
        }
    }
 
    {
        bool shows = this->GetColumn(colSinking)->IsShown();
        bool should_show = false;
        for (int i = 0; i < m_objects->size(); ++i) {
            if (wxGetApp().plater()->canvas3D()->is_object_sinking(i)) {
                should_show = true;
                break;
            }
            if (should_show)
                break;
        }
 
        if (shows && !should_show) {
            this->set_sinking_hidden(true);
        }
        else if (!shows && should_show) {
            this->set_sinking_hidden(false);
        }
    }
}

References Slic3r::GUI::colColorPaint, Slic3r::GUI::colSinking, Slic3r::GUI::colSupportPaint, Slic3r::GUI::CutConnectors, Slic3r::FacetsAnnotation::empty(), Slic3r::LayerHeightProfile::get(), Slic3r::ModelObject::has_connectors(), Slic3r::GUI::hiUnVariable, Slic3r::GUI::hiVariable, Slic3r::ModelObject::is_cut(), Slic3r::ModelObject::layer_height_profile, m_objects, m_objects_model, Slic3r::ModelVolume::mmu_segmentation_facets, Slic3r::GUI::plater(), Slic3r::GUI::printer_technology(), Slic3r::ptFFF, set_color_paint_hidden(), set_sinking_hidden(), set_support_paint_hidden(), Slic3r::ModelVolume::supported_facets, update_variable_layer_obj_num(), and Slic3r::ModelObject::volumes.

Referenced by add_object_to_list(), del_subobject_item(), delete_all_connectors_for_object(), delete_from_model_and_list(), fix_through_cgal(), instances_to_separated_object(), instances_to_separated_objects(), invalidate_cut_info_for_object(), list_manipulation(), OnEditingStarted(), reorder_volumes_and_get_selection(), split(), and update_object_list_by_printer_technology().

Here is the call graph for this function:

Here is the caller graph for this function:

update_item_error_icon()

void Slic3r::GUI::ObjectList::update_item_error_icon	(	const int	obj_idx,
		int	vol_idx ) const

{
    auto obj = object(obj_idx);
    if (wxDataViewItem obj_item = m_objects_model->GetItemById(obj_idx)) {
        const std::string& icon_name = get_warning_icon_name(obj->get_object_stl_stats());
        m_objects_model->UpdateWarningIcon(obj_item, icon_name);
    }
 
    if (vol_idx < 0)
        return;
 
    if (wxDataViewItem vol_item = m_objects_model->GetItemByVolumeId(obj_idx, vol_idx)) {
        const std::string& icon_name = get_warning_icon_name(obj->volumes[vol_idx]->mesh().stats());
        m_objects_model->UpdateWarningIcon(vol_item, icon_name);
    }
}

References Slic3r::GUI::get_warning_icon_name(), m_objects_model, and object().

Referenced by fix_through_cgal().

Here is the call graph for this function:

Here is the caller graph for this function:

update_lock_icons_for_model()

void Slic3r::GUI::ObjectList::update_lock_icons_for_model

(

)

{
    // update the icon for cut object
    for (size_t obj_idx = 0; obj_idx < (*m_objects).size(); ++obj_idx)
        if (!(*m_objects)[obj_idx]->is_cut())
            m_objects_model->UpdateCutObjectIcon(m_objects_model->GetItemById(int(obj_idx)), false);
}

References m_objects, and m_objects_model.

Referenced by delete_all_connectors_for_object(), delete_from_model_and_list(), delete_from_model_and_list(), and invalidate_cut_info_for_object().

Here is the caller graph for this function:

update_min_height()

void Slic3r::GUI::ObjectList::update_min_height

(

)

{
    wxDataViewItemArray all_items;
    m_objects_model->GetAllChildren(wxDataViewItem(nullptr), all_items);
    size_t items_cnt = all_items.Count();
#if 0
    if (items_cnt < 7)
        items_cnt = 7;
    else if (items_cnt >= 15)
        items_cnt = 15;
#else
    items_cnt = 8;
#endif
 
    if (m_items_count == items_cnt)
        return;
 
    m_items_count = items_cnt;
    set_min_height();
}

References m_items_count, m_objects_model, and set_min_height().

Referenced by part_selection_changed().

Here is the call graph for this function:

Here is the caller graph for this function:

update_name_column_width()

void Slic3r::GUI::ObjectList::update_name_column_width ( ) const

private

{
    wxSize client_size = this->GetClientSize();
    bool p_vbar = this->GetParent()->HasScrollbar(wxVERTICAL);
    bool p_hbar = this->GetParent()->HasScrollbar(wxHORIZONTAL);
 
    auto em = em_unit(const_cast<ObjectList*>(this));
    // BBS: walkaround for wxDataViewCtrl::HasScrollbar() does not return correct status
    int others_width = 0;
    for (int cn = colName; cn < colCount; cn++) {
        if (cn != colName) {
            if (!GetColumn(cn)->IsHidden())
                others_width += m_columns_width[cn];
        }
    }
 
    GetColumn(colName)->SetWidth(std::max(0, client_size.x - (others_width)*em));
}

References ObjectList(), Slic3r::GUI::colCount, Slic3r::GUI::colName, em_unit(), and m_columns_width.

Referenced by ObjectList(), set_color_paint_hidden(), set_filament_column_hidden(), set_sinking_hidden(), set_support_paint_hidden(), set_variable_height_column_hidden(), and update_variable_layer_obj_num().

Here is the call graph for this function:

Here is the caller graph for this function:

update_name_for_items()

void Slic3r::GUI::ObjectList::update_name_for_items

(

)

{
    m_objects_model->UpdateItemNames();
 
    wxGetApp().plater()->update();
}

References m_objects_model.

Referenced by Slic3r::GUI::Plater::_calib_pa_pattern().

Here is the caller graph for this function:

update_name_in_list()

void Slic3r::GUI::ObjectList::update_name_in_list	(	int	obj_idx,
		int	vol_idx ) const

{
    if (obj_idx < 0) return;
    wxDataViewItem item = GetSelection();
    if (!item || !(m_objects_model->GetItemType(item) & (itVolume | itObject)))
        return;
 
    wxString new_name = from_u8(object(obj_idx)->volumes[vol_idx]->name);
    if (new_name.IsEmpty() || m_objects_model->GetName(item) == new_name)
        return;
 
    m_objects_model->SetName(new_name, item);
}

References Slic3r::GUI::from_u8(), Slic3r::GUI::itObject, Slic3r::GUI::itVolume, and m_objects_model.

Referenced by anonymous_namespace{EmbossJob.cpp}::update_name_in_list().

Here is the call graph for this function:

Here is the caller graph for this function:

update_name_in_model()

void Slic3r::GUI::ObjectList::update_name_in_model

(

const wxDataViewItem &

item

)

const

{
    if (m_objects_model->GetItemType(item) & itPlate) {
        std::string name = m_objects_model->GetName(item).ToUTF8().data();
        int plate_idx = -1;
        const ItemType type0 = m_objects_model->GetItemType(item, plate_idx);
        if (plate_idx >= 0) {
            auto plate = wxGetApp().plater()->get_partplate_list().get_plate(plate_idx);
            if (plate->get_plate_name() != name) {
                plate->set_plate_name(name);
            }
            m_objects_model->SetCurSelectedPlateFullName(plate_idx, name);
        }
        return;
    }
 
    const int obj_idx = m_objects_model->GetObjectIdByItem(item);
    if (obj_idx < 0) return;
    const int volume_id = m_objects_model->GetVolumeIdByItem(item);
 
    take_snapshot(volume_id < 0 ? _u8L("Rename Object") : _u8L("Rename Part"));
 
    ModelObject* obj = object(obj_idx);
    if (m_objects_model->GetItemType(item) & itObject) {
        std::string name = m_objects_model->GetName(item).ToUTF8().data();
        if (obj->name != name) {
            const std::string previous_name = obj->name;
            obj->name = name;
            // if object has just one volume, rename this volume too
            if (obj->volumes.size() == 1)
                obj->volumes[0]->name = obj->name;
            Slic3r::save_object_mesh(*obj);
 
            LifecycleEventContext ctx;
            ctx.name = name;
            ctx.previous_name = previous_name;
            ctx.id = std::to_string(obj->id().id);
            ctx.index = obj_idx;
            ctx.source = "object";
            fire_lifecycle_event(LifecycleEvent::ObjectRenamed, ctx);
        }
        return;
    }
 
    if (volume_id < 0) return;
    std::string name = m_objects_model->GetName(item).ToUTF8().data();
    if (obj->volumes[volume_id]->name == name)
        return;
 
    const std::string previous_name = obj->volumes[volume_id]->name;
    obj->volumes[volume_id]->name = name;
 
    LifecycleEventContext ctx;
    ctx.name = name;
    ctx.previous_name = previous_name;
    ctx.id = std::to_string(obj->volumes[volume_id]->id().id);
    ctx.index = volume_id;
    ctx.source = "volume";
    fire_lifecycle_event(LifecycleEvent::ObjectRenamed, ctx);
}

References _u8L, Slic3r::fire_lifecycle_event(), Slic3r::LifecycleEventContext::id, Slic3r::ObjectBase::id(), Slic3r::ObjectID::id, Slic3r::LifecycleEventContext::index, Slic3r::GUI::itObject, Slic3r::GUI::itPlate, m_objects_model, Slic3r::LifecycleEventContext::name, Slic3r::ModelObject::name, object(), Slic3r::ObjectRenamed, Slic3r::LifecycleEventContext::previous_name, Slic3r::save_object_mesh(), Slic3r::LifecycleEventContext::source, Slic3r::GUI::take_snapshot(), and Slic3r::ModelObject::volumes.

Referenced by ItemValueChanged(), and rename_item().

Here is the call graph for this function:

Here is the caller graph for this function:

update_object_list_by_printer_technology()

void Slic3r::GUI::ObjectList::update_object_list_by_printer_technology

(

)

{
    m_prevent_canvas_selection_update = true;
    wxDataViewItemArray sel;
    GetSelections(sel); // stash selection
 
    wxDataViewItemArray object_items;
    m_objects_model->GetChildren(wxDataViewItem(nullptr), object_items);
 
    for (auto& object_item : object_items) {
        // update custom supports info
        update_info_items(m_objects_model->GetObjectIdByItem(object_item), &sel);
 
        // Update Settings Item for object
        update_settings_item_and_selection(object_item, sel);
 
        // Update settings for Volumes
        wxDataViewItemArray all_object_subitems;
        m_objects_model->GetChildren(object_item, all_object_subitems);
        for (auto item : all_object_subitems)
            if (m_objects_model->GetItemType(item) & itVolume)
                // update settings for volume
                update_settings_item_and_selection(item, sel);
 
        // Update Layers Items
        wxDataViewItem layers_item = m_objects_model->GetLayerRootItem(object_item);
        if (!layers_item)
            layers_item = add_layer_root_item(object_item);
        else if (printer_technology() == ptSLA) {
            // If layers root item will be deleted from the list, so
            // it's need to be deleted from selection array, if it was there
            wxDataViewItemArray del_items;
            bool some_layers_was_selected = false;
            m_objects_model->GetAllChildren(layers_item, del_items);
            for (auto& del_item:del_items)
                if (sel.Index(del_item) != wxNOT_FOUND) {
                    some_layers_was_selected = true;
                    sel.Remove(del_item);
                }
            if (sel.Index(layers_item) != wxNOT_FOUND) {
                some_layers_was_selected = true;
                sel.Remove(layers_item);
            }
 
            // delete all "layers" items
            m_objects_model->Delete(layers_item);
 
            // Select object_item, if layers_item doesn't exist for item anymore, but was some of layer items was/were selected
            if (some_layers_was_selected)
                sel.Add(object_item);
        }
        else {
            wxDataViewItemArray all_obj_layers;
            m_objects_model->GetChildren(layers_item, all_obj_layers);
 
            for (auto item : all_obj_layers)
                // update settings for layer
                update_settings_item_and_selection(item, sel);
        }
    }
 
    // restore selection:
    SetSelections(sel);
    m_prevent_canvas_selection_update = false;
}

References add_layer_root_item(), Slic3r::GUI::itVolume, m_objects_model, m_prevent_canvas_selection_update, Slic3r::GUI::printer_technology(), Slic3r::ptSLA, update_info_items(), and update_settings_item_and_selection().

Here is the call graph for this function:

update_objects_list_filament_column()

void Slic3r::GUI::ObjectList::update_objects_list_filament_column

(

size_t

filaments_count

)

{
    assert(filaments_count >= 1);
 
    if (printer_technology() == ptSLA)
        filaments_count = 1;
 
    m_prevent_update_filament_in_config = true;
 
    // BBS: update extruder values even when filaments_count is 1, because it may be reduced from value greater than 1
    if (m_objects)
        update_filament_values_for_items(filaments_count);
 
    update_filament_colors();
 
    // set show/hide for this column
    set_filament_column_hidden(filaments_count == 1);
    //a workaround for a wrong last column width updating under OSX
    auto em = em_unit(this);
    GetColumn(colEditing)->SetWidth(m_columns_width[colEditing]*em);
 
    m_prevent_update_filament_in_config = false;
}

References Slic3r::GUI::colEditing, em_unit(), Slic3r::GUI::filaments_count(), m_columns_width, m_objects, m_prevent_update_filament_in_config, Slic3r::GUI::printer_technology(), Slic3r::ptSLA, set_filament_column_hidden(), update_filament_colors(), and update_filament_values_for_items().

Referenced by Slic3r::GUI::Plater::on_filament_count_change(), and Slic3r::GUI::Sidebar::update_mixed_filament_list().

Here is the call graph for this function:

Here is the caller graph for this function:

update_objects_list_filament_column_when_delete_filament()

void Slic3r::GUI::ObjectList::update_objects_list_filament_column_when_delete_filament	(	size_t	filament_id,
		size_t	filaments_count,
		int	replace_filament_id = -1 )

{
    m_prevent_update_filament_in_config = true;
 
    // BBS: update extruder values even when filaments_count is 1, because it may be reduced from value greater than 1
    if (m_objects)
        update_filament_values_for_items_when_delete_filament(filament_id, replace_filament_id);
 
    update_filament_colors();
 
    // set show/hide for this column
    set_filament_column_hidden(filaments_count == 1);
    // a workaround for a wrong last column width updating under OSX
    GetColumn(colEditing)->SetWidth(25);
 
    m_prevent_update_filament_in_config = false;
}

References Slic3r::GUI::colEditing, Slic3r::GUI::filaments_count(), m_objects, m_prevent_update_filament_in_config, set_filament_column_hidden(), update_filament_colors(), and update_filament_values_for_items_when_delete_filament().

Referenced by Slic3r::GUI::Plater::on_filaments_delete().

Here is the call graph for this function:

Here is the caller graph for this function:

update_plate_values_for_items()

void Slic3r::GUI::ObjectList::update_plate_values_for_items

(

)

{
#ifdef __WXOSX__
    AssociateModel(nullptr);
#endif
    PartPlateList& list = wxGetApp().plater()->get_partplate_list();
    for (size_t i = 0; i < m_objects->size(); ++i)
    {
        wxDataViewItem item = m_objects_model->GetItemById(i);
        if (!item) continue;
 
        int plate_idx = list.find_instance_belongs(i, 0);
        wxDataViewItem old_parent = m_objects_model->GetParent(item);
        ObjectDataViewModelNode* old_parent_node = (ObjectDataViewModelNode*)old_parent.GetID();
        int old_plate_idx = old_parent_node->GetPlateIdx();
        if (plate_idx == old_plate_idx)
            continue;
 
        // hotfix for wxDataViewCtrl selection not updated after wxDataViewModel::ItemDeleted()
        Unselect(item);
 
        bool is_old_parent_expanded = IsExpanded(old_parent);
        bool is_expanded = IsExpanded(item);
        m_objects_model->OnPlateChange(plate_idx, item);
        if (is_old_parent_expanded)
            Expand(old_parent);
        ExpandAncestors(item);
        Expand(item);
        Select(item);
    }
#ifdef __WXOSX__
    AssociateModel(m_objects_model);
#endif
}

References Slic3r::GUI::PartPlateList::find_instance_belongs(), Slic3r::GUI::ObjectDataViewModelNode::GetPlateIdx(), m_objects, and m_objects_model.

Here is the call graph for this function:

update_printable_state()

void Slic3r::GUI::ObjectList::update_printable_state	(	int	obj_idx,
		int	instance_idx )

{
    ModelObject* object = (*m_objects)[obj_idx];
 
    const PrintIndicator printable = object->instances[instance_idx]->printable ? piPrintable : piUnprintable;
    if (object->instances.size() == 1)
        instance_idx = -1;
 
    m_objects_model->SetPrintableState(printable, obj_idx, instance_idx);
}

References m_objects_model, object(), Slic3r::GUI::piPrintable, and Slic3r::GUI::piUnprintable.

Here is the call graph for this function:

update_selection_mode()

void Slic3r::GUI::ObjectList::update_selection_mode

(

)

{
    m_selected_layers_range_idx=-1;
    // All items are unselected
    if (!GetSelection())
    {
        m_last_selected_item = wxDataViewItem(nullptr);
        m_selection_mode = smUndef;
        return;
    }
 
    const ItemType type = m_objects_model->GetItemType(GetSelection());
    m_selection_mode =  type & itSettings ? smUndef  :
                        type & itLayer    ? smLayer  :
                        type & itVolume   ? smVolume : smInstance;
}

References Slic3r::GUI::itLayer, Slic3r::GUI::itSettings, Slic3r::GUI::itVolume, m_last_selected_item, m_objects_model, m_selected_layers_range_idx, m_selection_mode, smInstance, smLayer, smUndef, and smVolume.

Referenced by fix_multiselection_conflicts().

Here is the caller graph for this function:

update_selections()

void Slic3r::GUI::ObjectList::update_selections

(

)

{
    if (wxGetApp().is_closing())
        return;
 
    const Selection& selection = scene_selection();
    wxDataViewItemArray sels;
 
#if 0
    if (m_selection_mode == smUndef) {
        PartPlate* pp = wxGetApp().plater()->get_partplate_list().get_selected_plate();
        assert(pp != nullptr);
        wxDataViewItem sel_plate = m_objects_model->GetItemByPlateId(pp->get_index());
        sels.Add(sel_plate);
        select_items(sels);
 
        // Scroll selected Item in the middle of an object list
        ensure_current_item_visible();
        return;
    }
#endif
 
    if ( ( m_selection_mode & (smSettings|smLayer|smLayerRoot|smVolume) ) == 0)
        m_selection_mode = smInstance;
 
    // We doesn't update selection if itSettings | itLayerRoot | itLayer Item for the current object/part is selected
    if (GetSelectedItemsCount() == 1 && m_objects_model->GetItemType(GetSelection()) & (itSettings | itLayerRoot | itLayer))
    {
        const auto item = GetSelection();
        if (selection.is_single_full_object()) {
            if (m_objects_model->GetItemType(m_objects_model->GetParent(item)) & itObject &&
                m_objects_model->GetObjectIdByItem(item) == selection.get_object_idx() )
                return;
            sels.Add(m_objects_model->GetItemById(selection.get_object_idx()));
        }
        else if (selection.is_single_volume() || selection.is_any_modifier()) {
            const auto gl_vol = selection.get_first_volume();
            if (m_objects_model->GetVolumeIdByItem(m_objects_model->GetParent(item)) == gl_vol->volume_idx())
                return;
        }
        // but if there is selected only one of several instances by context menu,
        // then select this instance in ObjectList
        else if (selection.is_single_full_instance())
            sels.Add(m_objects_model->GetItemByInstanceId(selection.get_object_idx(), selection.get_instance_idx()));
        // Can be the case, when we have selected itSettings | itLayerRoot | itLayer in the ObjectList and selected object/instance in the Scene
        // and then select some object/instance in 3DScene using Ctrt+left click
        else {
            // Unselect all items in ObjectList
            m_last_selected_item = wxDataViewItem(nullptr);
            m_prevent_list_events = true;
            UnselectAll();
            m_prevent_list_events = false;
            // call this function again to update selection from the canvas
            update_selections();
            return;
        }
    }
    else if (selection.is_single_full_object() || selection.is_multiple_full_object())
    {
        const Selection::ObjectIdxsToInstanceIdxsMap& objects_content = selection.get_content();
        // it's impossible to select Settings, Layer or LayerRoot for several objects
        if (!selection.is_multiple_full_object() && (m_selection_mode & (smSettings | smLayer | smLayerRoot)))
        {
            auto obj_idx = objects_content.begin()->first;
            wxDataViewItem obj_item = m_objects_model->GetItemById(obj_idx);
            if (m_selection_mode & smSettings)
            {
                if (m_selected_layers_range_idx < 0)
                    sels.Add(m_objects_model->GetSettingsItem(obj_item));
                else
                    sels.Add(m_objects_model->GetSettingsItem(m_objects_model->GetItemByLayerId(obj_idx, m_selected_layers_range_idx)));
            }
            else if (m_selection_mode & smLayerRoot)
                sels.Add(m_objects_model->GetLayerRootItem(obj_item));
            else if (m_selection_mode & smLayer) {
                if (m_selected_layers_range_idx >= 0)
                    sels.Add(m_objects_model->GetItemByLayerId(obj_idx, m_selected_layers_range_idx));
                else
                    sels.Add(obj_item);
            }
        }
        else {
        for (const auto& object : objects_content) {
            if (object.second.size() == 1)          // object with 1 instance
                sels.Add(m_objects_model->GetItemById(object.first));
            else if (object.second.size() > 1)      // object with several instances
            {
                wxDataViewItemArray current_sels;
                GetSelections(current_sels);
                const wxDataViewItem frst_inst_item = m_objects_model->GetItemByInstanceId(object.first, 0);
 
                bool root_is_selected = false;
                for (const auto& item:current_sels)
                    if (item == m_objects_model->GetParent(frst_inst_item) ||
                        item == m_objects_model->GetObject(frst_inst_item)) {
                        root_is_selected = true;
                        sels.Add(item);
                        break;
                    }
                if (root_is_selected)
                    continue;
 
                const Selection::InstanceIdxsList& instances = object.second;
                for (const auto& inst : instances)
                    sels.Add(m_objects_model->GetItemByInstanceId(object.first, inst));
            }
        } }
    }
    else if (selection.is_any_volume() || selection.is_any_modifier())
    {
        if (m_selection_mode & smSettings)
        {
            const auto gl_vol = selection.get_first_volume();
            if (gl_vol->volume_idx() >= 0) {
                // Only add GLVolumes with non-negative volume_ids. GLVolumes with negative volume ids
                // are not associated with ModelVolumes, but they are temporarily generated by the backend
                // (for example, SLA supports or SLA pad).
                wxDataViewItem vol_item = m_objects_model->GetItemByVolumeId(gl_vol->object_idx(), gl_vol->volume_idx());
                sels.Add(m_objects_model->GetSettingsItem(vol_item));
            }
        }
        else {
        for (auto idx : selection.get_volume_idxs()) {
            const auto gl_vol = selection.get_volume(idx);
            if (gl_vol->volume_idx() >= 0) {
                // Only add GLVolumes with non-negative volume_ids. GLVolumes with negative volume ids
                // are not associated with ModelVolumes, but they are temporarily generated by the backend
                // (for example, SLA supports or SLA pad).
                int obj_idx = gl_vol->object_idx();
                int vol_idx = gl_vol->volume_idx();
                assert(obj_idx >= 0 && vol_idx >= 0);
                if (object(obj_idx)->volumes[vol_idx]->is_cut_connector())
                    sels.Add(m_objects_model->GetInfoItemByType(m_objects_model->GetItemById(obj_idx), InfoItemType::CutConnectors));
                else {
                    vol_idx = m_objects_model->get_real_volume_index_in_ui(obj_idx,vol_idx);
                    sels.Add(m_objects_model->GetItemByVolumeId(obj_idx, vol_idx));
                }
            }
        }
        m_selection_mode = smVolume; }
    }
    else if (selection.is_single_full_instance() || selection.is_multiple_full_instance())
    {
        for (auto idx : selection.get_instance_idxs()) {
            sels.Add(m_objects_model->GetItemByInstanceId(selection.get_object_idx(), idx));
        }
    }
    else if (selection.is_mixed())
    {
        const Selection::ObjectIdxsToInstanceIdxsMap& objects_content_list = selection.get_content();
 
        for (auto idx : selection.get_volume_idxs()) {
            const auto gl_vol = selection.get_volume(idx);
            const auto& glv_obj_idx = gl_vol->object_idx();
            const auto& glv_ins_idx = gl_vol->instance_idx();
 
            bool is_selected = false;
 
            for (auto obj_ins : objects_content_list) {
                if (obj_ins.first == glv_obj_idx) {
                    if (obj_ins.second.find(glv_ins_idx) != obj_ins.second.end() &&
                        !selection.is_from_single_instance() ) // a case when volumes of different types are selected
                    {
                        if (glv_ins_idx == 0 && (*m_objects)[glv_obj_idx]->instances.size() == 1)
                            sels.Add(m_objects_model->GetItemById(glv_obj_idx));
                        else
                            sels.Add(m_objects_model->GetItemByInstanceId(glv_obj_idx, glv_ins_idx));
 
                        is_selected = true;
                        break;
                    }
                }
            }
 
            if (is_selected)
                continue;
 
            const auto& glv_vol_idx = gl_vol->volume_idx();
            if (glv_vol_idx == 0 && (*m_objects)[glv_obj_idx]->volumes.size() == 1)
                sels.Add(m_objects_model->GetItemById(glv_obj_idx));
            else
                sels.Add(m_objects_model->GetItemByVolumeId(glv_obj_idx, glv_vol_idx));
        }
    }
 
    if (sels.size() == 0 || m_selection_mode & smSettings)
        m_selection_mode = smUndef;
 
    if (fix_cut_selection(sels) || is_connectors_item_selected(sels)) {
        m_prevent_list_events = true;
 
        // If some part is selected, unselect all items except of selected parts of the current object
        UnselectAll();
        SetSelections(sels);
 
        m_prevent_list_events = false;
 
        // update object selection on Plater
        if (!m_prevent_canvas_selection_update)
            update_selections_on_canvas();
 
        // to update the toolbar and info sizer
        if (!GetSelection() || m_objects_model->GetItemType(GetSelection()) == itObject || is_connectors_item_selected()) {
            auto event = SimpleEvent(EVT_OBJ_LIST_OBJECT_SELECT);
            event.SetEventObject(this);
            wxPostEvent(this, event);
        }
        part_selection_changed();
    }
    else {
        select_items(sels);
 
        // Scroll selected Item in the middle of an object list
        ensure_current_item_visible();
    }
}

References Slic3r::GUI::CutConnectors, ensure_current_item_visible(), fix_cut_selection(), Slic3r::GUI::Selection::get_content(), Slic3r::GUI::Selection::get_first_volume(), Slic3r::GUI::PartPlate::get_index(), Slic3r::GUI::Selection::get_instance_idx(), Slic3r::GUI::Selection::get_instance_idxs(), Slic3r::GUI::Selection::get_object_idx(), Slic3r::GUI::Selection::get_volume(), Slic3r::GUI::Selection::get_volume_idxs(), Slic3r::GUI::Selection::is_any_modifier(), Slic3r::GUI::Selection::is_any_volume(), is_connectors_item_selected(), Slic3r::GUI::Selection::is_from_single_instance(), Slic3r::GUI::Selection::is_mixed(), Slic3r::GUI::Selection::is_multiple_full_instance(), Slic3r::GUI::Selection::is_multiple_full_object(), is_selected(), Slic3r::GUI::Selection::is_single_full_instance(), Slic3r::GUI::Selection::is_single_full_object(), Slic3r::GUI::Selection::is_single_volume(), Slic3r::GUI::itLayer, Slic3r::GUI::itLayerRoot, Slic3r::GUI::itObject, Slic3r::GUI::itSettings, m_last_selected_item, m_objects, m_objects_model, m_prevent_canvas_selection_update, m_prevent_list_events, m_selected_layers_range_idx, m_selection_mode, Slic3r::GLVolume::object_idx(), part_selection_changed(), Slic3r::GUI::scene_selection(), select_items(), smInstance, smLayer, smLayerRoot, smSettings, smUndef, smVolume, update_selections(), and update_selections_on_canvas().

Referenced by Slic3r::GUI::Plater::priv::on_select_preset(), reload_all_plates(), Slic3r::GUI::Plater::priv::remove_curr_plate_all(), Slic3r::GUI::Plater::priv::select_all(), Slic3r::GUI::Plater::priv::select_curr_plate_all(), Slic3r::GUI::Sidebar::update_mode(), and update_selections().

Here is the call graph for this function:

Here is the caller graph for this function:

update_selections_on_canvas()

void Slic3r::GUI::ObjectList::update_selections_on_canvas

(

)

{
    auto canvas_type = wxGetApp().plater()->get_current_canvas3D()->get_canvas_type();
    GLCanvas3D* canvas = canvas_type == GLCanvas3D::ECanvasType::CanvasAssembleView ? wxGetApp().plater()->get_current_canvas3D() : wxGetApp().plater()->get_view3D_canvas3D();
    Selection& selection = canvas->get_selection();
 
    const int sel_cnt = GetSelectedItemsCount();
    if (sel_cnt == 0) {
        selection.remove_all();
        if (canvas_type != GLCanvas3D::ECanvasType::CanvasPreview)
            wxGetApp().plater()->get_current_canvas3D()->update_gizmos_on_off_state();
        return;
    }
 
    std::vector<unsigned int> volume_idxs;
    Selection::EMode mode = Selection::Volume;
    bool single_selection = sel_cnt == 1;
    auto add_to_selection = [this, &volume_idxs, &single_selection](const wxDataViewItem& item, const Selection& selection, int instance_idx, Selection::EMode& mode)
    {
        const ItemType& type = m_objects_model->GetItemType(item);
        const int obj_idx = m_objects_model->GetObjectIdByItem(item);
 
        if (type == itVolume) {
            int vol_idx = m_objects_model->GetVolumeIdByItem(item);
            vol_idx                        = m_objects_model->get_real_volume_index_in_3d(obj_idx,vol_idx);
            std::vector<unsigned int> idxs = selection.get_volume_idxs_from_volume(obj_idx, std::max(instance_idx, 0), vol_idx);
            volume_idxs.insert(volume_idxs.end(), idxs.begin(), idxs.end());
        }
        else if (type == itInstance) {
            const int inst_idx = m_objects_model->GetInstanceIdByItem(item);
            mode = Selection::Instance;
            std::vector<unsigned int> idxs = selection.get_volume_idxs_from_instance(obj_idx, inst_idx);
            volume_idxs.insert(volume_idxs.end(), idxs.begin(), idxs.end());
        }
        else if (type == itInfo) {
            if (m_objects_model->GetInfoItemType(item) == InfoItemType::CutConnectors) {
                mode = Selection::Volume;
 
                // When selecting CutConnectors info item, select all object volumes, which are marked as a connector
                const ModelObject *obj = object(obj_idx);
                for (unsigned int vol_idx = 0; vol_idx < obj->volumes.size(); vol_idx++)
                    if (obj->volumes[vol_idx]->is_cut_connector()) {
                        std::vector<unsigned int> idxs = selection.get_volume_idxs_from_volume(obj_idx, std::max(instance_idx, 0), vol_idx);
                        volume_idxs.insert(volume_idxs.end(), idxs.begin(), idxs.end());
                    }
            } else {
                // When selecting an info item, select one instance of the
                // respective object - a gizmo may want to be opened.
                int inst_idx      = selection.get_instance_idx();
                int scene_obj_idx = selection.get_object_idx();
                mode              = Selection::Instance;
                // select first instance, unless an instance of the object is already selected
                if (scene_obj_idx == -1 || inst_idx == -1 || scene_obj_idx != obj_idx) inst_idx = 0;
                std::vector<unsigned int> idxs = selection.get_volume_idxs_from_instance(obj_idx, inst_idx);
                volume_idxs.insert(volume_idxs.end(), idxs.begin(), idxs.end());
            }
        }
        else
        {
            mode = Selection::Instance;
            single_selection &= (obj_idx != selection.get_object_idx());
            std::vector<unsigned int> idxs = selection.get_volume_idxs_from_object(obj_idx);
            volume_idxs.insert(volume_idxs.end(), idxs.begin(), idxs.end());
        }
    };
 
    // stores current instance idx before to clear the selection
    int instance_idx = selection.get_instance_idx();
 
    if (sel_cnt == 1) {
        wxDataViewItem item = GetSelection();
        if (m_objects_model->GetInfoItemType(item) == InfoItemType::CutConnectors)
            selection.remove_all();
 
        if (m_objects_model->GetItemType(item) & (itSettings | itInstanceRoot | itLayerRoot | itLayer))
            add_to_selection(m_objects_model->GetParent(item), selection, instance_idx, mode);
        else
            add_to_selection(item, selection, instance_idx, mode);
    }
    else
    {
        wxDataViewItemArray sels;
        GetSelections(sels);
 
        // clear selection before adding new elements
        selection.clear(); //OR remove_all()?
 
        for (auto item : sels)
        {
            add_to_selection(item, selection, instance_idx, mode);
        }
    }
 
    if (selection.contains_all_volumes(volume_idxs))
    {
        // remove
        volume_idxs = selection.get_missing_volume_idxs_from(volume_idxs);
        if (volume_idxs.size() > 0)
        {
            Plater::TakeSnapshot snapshot(wxGetApp().plater(), "Remove selected from list", UndoRedo::SnapshotType::Selection);
            selection.remove_volumes(mode, volume_idxs);
        }
    }
    else
    {
        // add
        // to avoid lost of some volumes in selection
        // check non-selected volumes only if selection mode wasn't changed
        // OR there is no single selection
        if (selection.get_mode() == mode || !single_selection)
            volume_idxs = selection.get_unselected_volume_idxs_from(volume_idxs);
        Plater::TakeSnapshot snapshot(wxGetApp().plater(), "Add selected to list", UndoRedo::SnapshotType::Selection);
        selection.add_volumes(mode, volume_idxs, single_selection);
    }
 
    if (canvas_type != GLCanvas3D::ECanvasType::CanvasPreview)
        wxGetApp().plater()->get_current_canvas3D()->update_gizmos_on_off_state();
    wxGetApp().plater()->canvas3D()->render();
}

References Slic3r::GUI::Selection::add_volumes(), Slic3r::GUI::GLCanvas3D::CanvasAssembleView, Slic3r::GUI::GLCanvas3D::CanvasPreview, Slic3r::GUI::Selection::clear(), Slic3r::GUI::Selection::contains_all_volumes(), Slic3r::GUI::CutConnectors, Slic3r::GUI::Selection::get_instance_idx(), Slic3r::GUI::Selection::get_missing_volume_idxs_from(), Slic3r::GUI::Selection::get_mode(), Slic3r::GUI::Selection::get_object_idx(), Slic3r::GUI::GLCanvas3D::get_selection(), Slic3r::GUI::Selection::get_unselected_volume_idxs_from(), Slic3r::GUI::Selection::get_volume_idxs_from_instance(), Slic3r::GUI::Selection::get_volume_idxs_from_object(), Slic3r::GUI::Selection::get_volume_idxs_from_volume(), Slic3r::GUI::Selection::Instance, Slic3r::GUI::itInfo, Slic3r::GUI::itInstance, Slic3r::GUI::itInstanceRoot, Slic3r::GUI::itLayer, Slic3r::GUI::itLayerRoot, Slic3r::GUI::itSettings, Slic3r::GUI::itVolume, m_objects_model, object(), Slic3r::GUI::plater(), Slic3r::GUI::Selection::remove_all(), Slic3r::GUI::Selection::remove_volumes(), Slic3r::UndoRedo::Selection, Slic3r::GUI::Selection::Volume, and Slic3r::ModelObject::volumes.

Referenced by boolean(), merge(), remove(), selection_changed(), show_settings(), and update_selections().

Here is the call graph for this function:

Here is the caller graph for this function:

update_settings_item_and_selection()

void Slic3r::GUI::ObjectList::update_settings_item_and_selection	(	wxDataViewItem	item,
		wxDataViewItemArray &	selections )

{
    const wxDataViewItem old_settings_item = m_objects_model->GetSettingsItem(item);
    const wxDataViewItem new_settings_item = add_settings_item(item, &get_item_config(item).get());
 
    if (!new_settings_item && old_settings_item)
        m_objects_model->Delete(old_settings_item);
 
    // if ols settings item was is selected area
    if (selections.Index(old_settings_item) != wxNOT_FOUND)
    {
        // If settings item was just updated
        if (old_settings_item == new_settings_item)
        {
            Sidebar& panel = wxGetApp().sidebar();
            panel.Freeze();
 
            // update settings list
            wxGetApp().obj_settings()->UpdateAndShow(true);
 
            panel.Layout();
            panel.Thaw();
        }
        else
        // If settings item was deleted from the list,
        // it's need to be deleted from selection array, if it was there
        {
            selections.Remove(old_settings_item);
 
            // Select item, if settings_item doesn't exist for item anymore, but was selected
            if (selections.Index(item) == wxNOT_FOUND) {
                selections.Add(item);
                select_item(item); // to correct update of the SettingsList and ManipulationPanel sizers
            }
        }
    }
}

References add_settings_item(), get_item_config(), m_objects_model, Slic3r::GUI::Sidebar::obj_settings(), select_item(), and Slic3r::GUI::ObjectSettings::UpdateAndShow().

Referenced by update_object_list_by_printer_technology().

Here is the call graph for this function:

Here is the caller graph for this function:

update_variable_layer_obj_num()

void Slic3r::GUI::ObjectList::update_variable_layer_obj_num	(	ObjectDataViewModelNode *	obj_node,
		size_t	layer_data_count )

                                                                                                         {
    if (obj_node){
        if (obj_node->IsVaribaleHeight() == hiVariable && layer_data_count <= 4){
            m_variable_layer_obj_num--;
        }
        else if (obj_node->IsVaribaleHeight() == hiUnVariable && layer_data_count > 4){
            m_variable_layer_obj_num++;
        }
        GetColumn(colHeight)->SetHidden(m_variable_layer_obj_num == 0);
        update_name_column_width();
    }
}

References Slic3r::GUI::colHeight, Slic3r::GUI::hiUnVariable, Slic3r::GUI::hiVariable, Slic3r::GUI::ObjectDataViewModelNode::IsVaribaleHeight(), m_variable_layer_obj_num, and update_name_column_width().

Referenced by update_info_items().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_bmp_vector

std::vector<wxBitmap*> Slic3r::GUI::ObjectList::m_bmp_vector

private

m_clipboard

Clipboard Slic3r::GUI::ObjectList::m_clipboard

private

Referenced by can_paste_settings_into_list(), clipboard_is_empty(), copy_layers_to_clipboard(), copy_settings_to_clipboard(), copy_to_clipboard(), paste_from_clipboard(), paste_layers_into_list(), and paste_settings_into_list().

m_columns_width

std::vector<int> Slic3r::GUI::ObjectList::m_columns_width

private

Referenced by create_objects_ctrl(), msw_rescale(), update_name_column_width(), and update_objects_list_filament_column().

m_config

ModelConfig* Slic3r::GUI::ObjectList::m_config {nullptr}

private

{nullptr};

Referenced by add_category_to_settings_from_frequent(), add_category_to_settings_from_selection(), config(), del_settings_from_config(), part_selection_changed(), and update_filament_in_config().

m_dragged_data

struct Slic3r::GUI::ObjectList::dragged_item_data Slic3r::GUI::ObjectList::m_dragged_data

private

Referenced by can_drop(), OnBeginDrag(), and OnDrop().

m_extruder_editor

BitmapComboBox* Slic3r::GUI::ObjectList::m_extruder_editor { nullptr }

private

{ nullptr };

Referenced by extruder_editing(), list_manipulation(), and part_selection_changed().

m_items_count

size_t Slic3r::GUI::ObjectList::m_items_count { size_t(-1) }

private

{ size_t(-1) };

Referenced by set_min_height(), and update_min_height().

m_last_selected_item

wxDataViewItem Slic3r::GUI::ObjectList::m_last_selected_item {nullptr}

private

{nullptr};

Referenced by ObjectList(), check_last_selection(), fix_multiselection_conflicts(), load_subobject(), paste_volumes_into_list(), select_items(), update_selection_mode(), and update_selections().

m_last_size

wxSize Slic3r::GUI::ObjectList::m_last_size

private

Referenced by ObjectList().

m_objects

std::vector<ModelObject*>* Slic3r::GUI::ObjectList::m_objects { nullptr }

private

{ nullptr };

Referenced by apply_volumes_order(), boolean(), can_merge_to_single_object(), can_mesh_boolean(), copy_layers_to_clipboard(), del_info_item(), delete_all_connectors_for_object(), fix_all_through_cgal(), get_selected_model_volume(), get_volume_by_item(), has_selected_cut_object(), init(), instances_to_separated_object(), instances_to_separated_objects(), invalidate_cut_info_for_object(), is_splittable(), last_volume_is_deleted(), load_shape_object(), load_subobject(), merge(), object(), objects(), OnDrop(), paste_layers_into_list(), paste_volumes_into_list(), reload_all_plates(), reorder_volumes_and_get_selection(), select_item_all_children(), set_extruder_for_selected_items(), set_volume_type(), update_filament_in_config(), update_filament_values_for_items(), update_filament_values_for_items_when_delete_filament(), update_info_items(), update_lock_icons_for_model(), update_objects_list_filament_column(), update_objects_list_filament_column_when_delete_filament(), update_plate_values_for_items(), and update_selections().

m_objects_model

ObjectDataViewModel* Slic3r::GUI::ObjectList::m_objects_model { nullptr }

private

{ nullptr };

Referenced by ~ObjectList(), add_category_to_settings_from_frequent(), add_category_to_settings_from_selection(), add_layer_item(), add_layer_range_after_current(), add_layer_root_item(), add_object_to_list(), add_objects_to_list(), add_settings_item(), add_volumes_to_object_in_list(), assembly_plate_object_name(), boolean(), can_drop(), can_merge_to_multipart_object(), can_paste_settings_into_list(), check_last_selection(), copy_layers_to_clipboard(), copy_settings_to_clipboard(), copy_to_clipboard(), create_objects_ctrl(), decrease_object_instances(), del_layer_range(), del_settings_from_config(), del_subobject_from_object(), del_subobject_item(), delete_all_connectors_for_object(), delete_all_connectors_for_selection(), delete_from_model_and_list(), delete_instance_from_list(), delete_object_from_list(), delete_object_from_list(), delete_volume_from_list(), edit_layer_range(), enable_layers_editing(), extruder_editing(), fix_cut_selection(), fix_multiselection_conflicts(), get_item_config(), get_mesh_errors_info(), get_selected_item_indexes(), get_selected_layers_range_idx(), get_selected_model_volume(), get_selected_obj_idx(), get_selection_indexes(), get_volume_by_item(), GetModel(), has_selected_cut_object(), increase_object_instances(), init(), invalidate_cut_info_for_selection(), is_connectors_item_selected(), is_connectors_item_selected(), is_selected(), is_splittable(), ItemValueChanged(), layers_editing(), list_manipulation(), load_subobject(), merge(), msw_rescale(), object_config_options_changed(), on_plate_added(), on_plate_deleted(), on_plate_selected(), OnBeginDrag(), OnDrop(), OnEditingDone(), OnStartEditing(), part_selection_changed(), paste_layers_into_list(), paste_objects_into_list(), paste_settings_into_list(), printable_state_changed(), reload_all_plates(), remove(), rename_item(), select_item_all_children(), select_items(), select_object_item(), selected_instances_of_same_object(), selection_changed(), set_extruder_for_selected_items(), set_tooltip_for_item(), set_volume_type(), show_context_menu(), split(), sys_color_changed(), toggle_auto_drop(), toggle_printable_state(), update_filament_colors(), update_filament_in_config(), update_filament_values_for_items(), update_filament_values_for_items_when_delete_filament(), update_info_items(), update_item_error_icon(), update_lock_icons_for_model(), update_min_height(), update_name_for_items(), update_name_in_list(), update_name_in_model(), update_object_list_by_printer_technology(), update_plate_values_for_items(), update_printable_state(), update_selection_mode(), update_selections(), update_selections_on_canvas(), and update_settings_item_and_selection().

m_prevent_canvas_selection_update

bool Slic3r::GUI::ObjectList::m_prevent_canvas_selection_update = false

private

Referenced by reload_all_plates(), selection_changed(), show_settings(), update_object_list_by_printer_technology(), and update_selections().

m_prevent_list_events

bool Slic3r::GUI::ObjectList::m_prevent_list_events = false

private

Referenced by ObjectList(), add_volumes_to_object_in_list(), delete_all_objects_from_list(), delete_from_model_and_list(), edit_layer_range(), fix_cut_selection(), fix_multiselection_conflicts(), merge(), OnBeginDrag(), OnDropPossible(), reload_all_plates(), select_item(), select_item(), select_items(), select_object_item(), selection_changed(), set_volume_type(), unselect_objects(), and update_selections().

m_prevent_list_manipulation

bool Slic3r::GUI::ObjectList::m_prevent_list_manipulation = false

private

Referenced by list_manipulation(), select_item(), and select_items().

m_prevent_update_filament_in_config

bool Slic3r::GUI::ObjectList::m_prevent_update_filament_in_config = false

private

Referenced by update_filament_in_config(), update_objects_list_filament_column(), and update_objects_list_filament_column_when_delete_filament().

m_selected_layers_range_idx

int Slic3r::GUI::ObjectList::m_selected_layers_range_idx {-1}

private

{-1};

Referenced by set_selected_layers_range_idx(), update_selection_mode(), and update_selections().

m_selected_object_id

int Slic3r::GUI::ObjectList::m_selected_object_id = -1

private

Referenced by edit_layer_range(), edit_layer_range(), and part_selection_changed().

m_selection_mode

SELECTION_MODE Slic3r::GUI::ObjectList::m_selection_mode {smUndef}

private

{smUndef};

Referenced by check_last_selection(), fix_multiselection_conflicts(), load_subobject(), paste_volumes_into_list(), remove(), select_item_all_children(), set_selection_mode(), update_selection_mode(), and update_selections().

m_variable_layer_obj_num

size_t Slic3r::GUI::ObjectList::m_variable_layer_obj_num = 0

private

Referenced by delete_from_model_and_list(), delete_from_model_and_list(), and update_variable_layer_obj_num().

---

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

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