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

Inheritance diagram for Slic3r::GUI::ObjectGridTable:

Collaboration diagram for Slic3r::GUI::ObjectGridTable:

Classes
struct	ObjectGridRow
struct	ObjectGridCol

Public Types
enum	GridRowType { row_object = 0 , row_volume = 1 }
enum	GridColType { col_printable = 0 , col_printable_reset = 1 , col_plate_index = 2 , col_name = 3 , col_filaments = 4 , col_filaments_reset = 5 , col_layer_height = 6 , col_layer_height_reset = 7 , col_wall_loops = 8 , col_wall_loops_reset = 9 , col_fill_density = 10 , col_fill_density_reset = 11 , col_enable_support = 12 , col_enable_support_reset = 13 , col_brim_type = 14 , col_brim_type_reset = 15 , col_speed_perimeter = 16 , col_speed_perimeter_reset = 17 , col_max }
typedef std::function< bool(ObjectGridRow row1, ObjectGridRow row2)>	compare_row_func

Public Member Functions
	ObjectGridTable (ObjectTablePanel *panel)
	~ObjectGridTable ()
void	release_object_configs ()
wxString	convert_filament_string (int index, wxString &filament_str)
virtual int	GetNumberRows () wxOVERRIDE
virtual int	GetNumberCols () wxOVERRIDE
virtual bool	IsEmptyCell (int row, int col) wxOVERRIDE
virtual wxString	GetTypeName (int row, int col) wxOVERRIDE
virtual bool	CanGetValueAs (int row, int col, const wxString &typeName) wxOVERRIDE
virtual bool	CanSetValueAs (int row, int col, const wxString &typeName) wxOVERRIDE
virtual wxString	GetValue (int row, int col) wxOVERRIDE
virtual void	SetValue (int row, int col, const wxString &value) wxOVERRIDE
virtual long	GetValueAsLong (int row, int col) wxOVERRIDE
virtual bool	GetValueAsBool (int row, int col) wxOVERRIDE
virtual double	GetValueAsDouble (int row, int col) wxOVERRIDE
virtual void	SetValueAsLong (int row, int col, long value) wxOVERRIDE
virtual void	SetValueAsBool (int row, int col, bool value) wxOVERRIDE
virtual void	SetValueAsDouble (int row, int col, double value) wxOVERRIDE
void	SetColLabelValue (int col, const wxString &) wxOVERRIDE
wxString	GetColLabelValue (int col) wxOVERRIDE
template<typename TYPE>
const TYPE *	get_object_config_value (const DynamicPrintConfig &global_config, ModelConfig *obj_config, std::string &config_option)
template<typename TYPE>
const TYPE *	get_volume_config_value (const DynamicPrintConfig &global_config, ModelConfig obj_config, ModelConfig volume_config, std::string &config_option)
int	get_row_count ()
int	get_col_count ()
ObjectGridCol *	get_grid_col (int col)
ObjectGridRow *	get_grid_row (int row)
void	construct_object_configs (ObjectGrid *object_grid)
void	update_value_to_config (ModelConfig *config, std::string &key, ConfigOption &new_value, ConfigOption &ori_value)
void	update_filament_to_config (ModelConfig *config, std::string &key, ConfigOption &new_value, ConfigOption &ori_value, bool is_object)
void	update_volume_values_from_object (int row, int col)
void	update_value_to_object (Model model, ObjectGridRow grid_row, int col)
wxBitmap &	get_undo_bitmap (bool selected=false)
wxBitmap *	get_color_bitmap (int color_index)
bool	OnCellLeftClick (int row, int col, ConfigOptionType &type)
void	OnSelectCell (int row, int col)
void	OnRangeSelected (int row, int col, int row_count, int col_count)
void	OnCellValueChanged (int row, int col)
void	SetSelection (int object_id, int volume_id)
void	sort_by_default ()
void	sort_by_col (int col)
void	reload_object_data (ObjectGridRow *grid_row, const std::string &category, DynamicPrintConfig &global_config)
void	reload_part_data (ObjectGridRow volume_row, ObjectGridRow object_row, const std::string &category, DynamicPrintConfig &global_config)
void	reload_cell_data (int row, const std::string &category)
void	resetValuesInCurrentCell (wxEvent &WXUNUSED(event))
void	enable_reset_all_button (bool enable)

Public Attributes
int	m_icon_col_width { 0 }
int	m_icon_row_height { 0 }
ObjectTablePanel *	m_panel { nullptr }

Static Public Attributes
static std::string	category_all = "All"
static std::string	plate_outside = L("Outside")

Private Member Functions
void	init_cols (ObjectGrid *object_grid)
void	sort_row_data (compare_row_func sort_func)
void	update_row_properties ()

Private Attributes
std::vector< ObjectGridRow * >	m_grid_data
std::vector< ObjectGridCol * >	m_col_data
bool	m_data_valid {false}
std::list< wxGridCellCoords >	m_selected_cells
int	m_sort_col { -1 }
int	m_current_row {-1}
int	m_current_col {-1}
wxArrayString	m_colLabels

Detailed Description

Member Typedef Documentation

◆ compare_row_func

typedef std::function<bool(ObjectGridRow* row1, ObjectGridRow* row2)> Slic3r::GUI::ObjectGridTable::compare_row_func

Member Enumeration Documentation

◆ GridColType

enum Slic3r::GUI::ObjectGridTable::GridColType

Enumerator
col_printable
col_printable_reset
col_plate_index
col_name
col_filaments
col_filaments_reset
col_layer_height
col_layer_height_reset
col_wall_loops
col_wall_loops_reset
col_fill_density
col_fill_density_reset
col_enable_support
col_enable_support_reset
col_brim_type
col_brim_type_reset
col_speed_perimeter
col_speed_perimeter_reset
col_max

    {
      /*  col_plate_index = 0,
        col_assemble_name = 1,
        col_name = col_assemble_name + 1,
        col_printable = col_name + 1,
        col_printable_reset = col_printable + 1,
        col_filaments = col_printable_reset + 1,
        col_filaments_reset = col_filaments + 1,
        col_layer_height = col_filaments_reset + 1,
        col_layer_height_reset = col_layer_height + 1,
        col_wall_loops = col_layer_height_reset + 1,
        col_wall_loops_reset = col_wall_loops + 1,
        col_fill_density = col_wall_loops_reset + 1,
        col_fill_density_reset = col_fill_density + 1,
        col_enable_support = col_fill_density_reset + 1,
        col_enable_support_reset = col_enable_support + 1,
        col_brim_type = col_enable_support_reset + 1,
        col_brim_type_reset = col_brim_type + 1,
        col_speed_perimeter = col_brim_type_reset + 1,
        col_speed_perimeter_reset = col_speed_perimeter + 1,
        col_max*/
        col_printable             = 0,
        col_printable_reset       = 1,
        col_plate_index           = 2,
        //col_assemble_name         = 3,
        col_name                  = 3,
        col_filaments             = 4,
        col_filaments_reset       = 5,
        col_layer_height          = 6,
        col_layer_height_reset    = 7,
        col_wall_loops            = 8,
        col_wall_loops_reset      = 9,
        col_fill_density          = 10,
        col_fill_density_reset    = 11,
        col_enable_support        = 12,
        col_enable_support_reset  = 13,
        col_brim_type             = 14,
        col_brim_type_reset       = 15,
        col_speed_perimeter       = 16,
        col_speed_perimeter_reset = 17,
        col_max
    };

◆ GridRowType

enum Slic3r::GUI::ObjectGridTable::GridRowType

Enumerator
row_object
row_volume

    {
        row_object = 0,
        row_volume = 1
    };

Constructor & Destructor Documentation

◆ ObjectGridTable()

Slic3r::GUI::ObjectGridTable::ObjectGridTable ( ObjectTablePanel * panel )

inline

451: m_panel(panel) { }

Slic3r::GUI::ObjectGridTable::m_panel

ObjectTablePanel * m_panel

Definition GUI_ObjectTable.hpp:538

References m_panel.

◆ ~ObjectGridTable()

Slic3r::GUI::ObjectGridTable::~ObjectGridTable ( )

{
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(", this %1%, row_data size %2%") %this % m_grid_data.size();
    for ( int index = 0; index < m_grid_data.size(); index++ )
    {
        if (m_grid_data[index])
            delete (m_grid_data[index]);
    }
    m_grid_data.clear();
 
    for ( int index = 0; index < m_col_data.size(); index++ )
    {
        if (m_col_data[index])
            delete (m_col_data[index]);
    }
 
    m_selected_cells.clear();
}

References m_col_data, m_grid_data, and m_selected_cells.

Member Function Documentation

◆ CanGetValueAs()

bool Slic3r::GUI::ObjectGridTable::CanGetValueAs	(	int	row,
		int	col,
		const wxString &	typeName )

virtual

{
    //row 0 always use string type for label
    if (row == 0) {
        if ( typeName == wxGRID_VALUE_STRING )
            return true;
        else
            return false;
    }
 
    //other rows for data
    ObjectGridCol* col_object = m_col_data[col];
    ObjectGridRow* row_object = m_grid_data[row - 1];
    ConfigOptionType option_type = col_object->type;
 
    if (col_object->b_icon)
        return false;
    if (col_object->b_for_object && (row_object->row_type == row_volume))
        return false;
 
    if ( typeName == wxGRID_VALUE_STRING )
    {
        if (option_type == coString)
            return true;
        else
            return false;
    }
    else if ( typeName == wxGRID_VALUE_BOOL )
    {
        if (option_type == coBool)
            return true;
        else
            return false;
    }
    else if ( typeName == wxGRID_VALUE_NUMBER )
    {
        if (option_type == coInt)
            return true;
        else
            return false;
    }
    else if ( typeName == wxGRID_VALUE_FLOAT  )
    {
        if ((option_type == coFloat) || (option_type == coPercent))
            return true;
        else
            return false;
    }
    else if ( typeName == wxGRID_VALUE_CHOICE )
    {
        if (option_type == coEnum)
            return true;
        else
            return false;
    }
    else
    {
        return false;
    }
}

References Slic3r::GUI::ObjectGridTable::ObjectGridCol::b_for_object, Slic3r::GUI::ObjectGridTable::ObjectGridCol::b_icon, Slic3r::coBool, Slic3r::coEnum, Slic3r::coFloat, Slic3r::coInt, Slic3r::coPercent, Slic3r::coString, m_col_data, m_grid_data, row_object, row_volume, and Slic3r::GUI::ObjectGridTable::ObjectGridCol::type.

Referenced by CanSetValueAs().

Here is the caller graph for this function:

◆ CanSetValueAs()

bool Slic3r::GUI::ObjectGridTable::CanSetValueAs	(	int	row,
		int	col,
		const wxString &	typeName )

virtual

{
    return CanGetValueAs(row, col, typeName);
}

References CanGetValueAs().

Here is the call graph for this function:

◆ construct_object_configs()

void Slic3r::GUI::ObjectGridTable::construct_object_configs ( ObjectGrid * object_grid )

{
    //release first
    release_object_configs();
 
    //init cols
    init_cols(object_grid);
 
    if (!m_panel->m_model)
    {
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << "found invalid m_model, should not happen" << std::endl;
        return;
    }
    int object_count = m_panel->m_model->objects.size();
    PartPlateList& partplate_list = m_panel->m_plater->get_partplate_list();
    DynamicPrintConfig&  global_config   = wxGetApp().preset_bundle->prints.get_edited_preset().config;
    const DynamicPrintConfig* plater_config = m_panel->m_plater->config();
    const DynamicPrintConfig&  filament_config = *plater_config;
 
    for (int i = 0; i < object_count; i++)
    {
        ModelObject* object = m_panel->m_model->objects[i];
        ObjectGridRow* object_grid = new ObjectGridRow(i, 0, row_object);
        int plate_index;
 
        object_grid->config = &(object->config);
        object_grid->name.value = object->name;
        object_grid->ori_name = object_grid->name;
        plate_index = partplate_list.find_instance_belongs(i, 0);
        if (plate_index == -1)
            object_grid->plate_index.value = ObjectGridTable::plate_outside;
        else
            object_grid->plate_index.value = /*std::string("Plate ") + */std::to_string(plate_index+1);
       /* object_grid->assemble_name.value = object->module_name;
        object_grid->ori_assemble_name = object_grid->assemble_name;*/
        object_grid->printable.value = object->instances[0]->printable;
        object_grid->ori_printable.value = object_grid->printable.value;
        //auto extruder_id_ptr = get_object_config_value<ConfigOptionInt>(filament_config, object_grid->config, m_col_data[col_filaments]->key);
        auto extruder_id_ptr = static_cast<const ConfigOptionInt*>(object_grid->config->option(m_col_data[col_filaments]->key));
        if (extruder_id_ptr) {
            object_grid->filaments = *extruder_id_ptr;
            if (object_grid->filaments.value == 0) {
                object_grid->filaments.value = 1;
                object_grid->config->set_key_value(m_col_data[col_filaments]->key, object_grid->filaments.clone());
            }
        }
        else {
            object_grid->filaments.value = 1;
            object_grid->config->set_key_value(m_col_data[col_filaments]->key, object_grid->filaments.clone());
        }
        //object_grid->ori_filaments.value = 1;
 
        object_grid->layer_height = *(get_object_config_value<ConfigOptionFloat>(global_config, object_grid->config, m_col_data[col_layer_height]->key));
        object_grid->ori_layer_height = *(global_config.option<ConfigOptionFloat>(m_col_data[col_layer_height]->key));
        object_grid->wall_loops = *(get_object_config_value<ConfigOptionInt>(global_config, object_grid->config, m_col_data[col_wall_loops]->key));
        object_grid->ori_wall_loops = *(global_config.option<ConfigOptionInt>(m_col_data[col_wall_loops]->key));
        object_grid->sparse_infill_density = *(get_object_config_value<ConfigOptionPercent>(global_config, object_grid->config, m_col_data[col_fill_density]->key));
        object_grid->ori_fill_density = *(global_config.option<ConfigOptionPercent>(m_col_data[col_fill_density]->key));
        object_grid->enable_support = *(get_object_config_value<ConfigOptionBool>(global_config, object_grid->config, m_col_data[col_enable_support]->key));
        object_grid->ori_enable_support = *(global_config.option<ConfigOptionBool>(m_col_data[col_enable_support]->key));
        object_grid->brim_type = *(get_object_config_value<ConfigOptionEnum<BrimType>>(global_config, object_grid->config, m_col_data[col_brim_type]->key));
        object_grid->ori_brim_type = *(global_config.option<ConfigOptionEnum<BrimType>>(m_col_data[col_brim_type]->key));
        object_grid->speed_perimeter       = *(get_object_config_value<ConfigOptionFloatsNullable>(global_config, object_grid->config, m_col_data[col_speed_perimeter]->key));
        object_grid->ori_speed_perimeter   = *(global_config.option<ConfigOptionFloatsNullable>(m_col_data[col_speed_perimeter]->key));
        m_grid_data.push_back(object_grid);
 
        int volume_count = object->volumes.size();
        if (volume_count <= 1)
            continue;
 
        for (int j = 0; j < volume_count; j++)
        {
            ModelVolume* volume = object->volumes[j];
            ObjectGridRow* volume_grid = new ObjectGridRow(i, j, row_volume);
            volume_grid->model_volume_type = volume->type();
            volume_grid->config = &(volume->config);
            volume_grid->name.value = volume->name;
            size_t pos = volume_grid->name.value.find_first_not_of(' ');
            if (pos > 0)
                volume_grid->name.value.erase(0, pos);
            volume_grid->ori_name = volume_grid->name;
            plate_index = partplate_list.find_instance_belongs(i, 0);
            if (plate_index == -1)
                volume_grid->plate_index.value = ObjectGridTable::plate_outside;
            else
                volume_grid->plate_index.value = /*std::string("Plate ") +*/ std::to_string(plate_index+1);
           /* volume_grid->assemble_name.value = object->module_name;
            volume_grid->ori_assemble_name = volume_grid->assemble_name;*/
            volume_grid->printable.value = object->instances[0]->printable;
            volume_grid->ori_printable.value = volume_grid->printable.value;
            //auto extruder_id_ptr = get_volume_config_value<ConfigOptionInt>(filament_config, object_grid->config, volume_grid->config, m_col_data[col_filaments]->key);
            auto extruder_id_ptr = static_cast<const ConfigOptionInt*>(volume_grid->config->option(m_col_data[col_filaments]->key));
            if (extruder_id_ptr) {
                volume_grid->filaments = *extruder_id_ptr;
                if ((volume_grid->filaments.value == 0) || (volume_grid->filaments == object_grid->filaments)) {
                    volume_grid->config->erase(m_col_data[col_filaments]->key);
                    volume_grid->filaments = object_grid->filaments;
                }
            }
            else
                volume_grid->filaments = object_grid->filaments;
            //volume_grid->ori_filaments = object_grid->filaments;
            volume_grid->layer_height = *(get_volume_config_value<ConfigOptionFloat>(global_config, object_grid->config, volume_grid->config, m_col_data[col_layer_height]->key));
            volume_grid->ori_layer_height = object_grid->layer_height;
            volume_grid->wall_loops = *(get_volume_config_value<ConfigOptionInt>(global_config, object_grid->config, volume_grid->config, m_col_data[col_wall_loops]->key));
            volume_grid->ori_wall_loops = object_grid->wall_loops;
            volume_grid->sparse_infill_density = *(get_volume_config_value<ConfigOptionPercent>(global_config, object_grid->config, volume_grid->config, m_col_data[col_fill_density]->key));
            volume_grid->ori_fill_density = object_grid->sparse_infill_density;
            volume_grid->enable_support = *(get_volume_config_value<ConfigOptionBool>(global_config, object_grid->config, volume_grid->config, m_col_data[col_enable_support]->key));
            volume_grid->ori_enable_support = object_grid->enable_support;
            volume_grid->brim_type = *(get_volume_config_value<ConfigOptionEnum<BrimType>>(global_config, object_grid->config, volume_grid->config, m_col_data[col_brim_type]->key));
            volume_grid->ori_brim_type = object_grid->brim_type;
            volume_grid->speed_perimeter = *(get_volume_config_value<ConfigOptionFloatsNullable>(global_config, object_grid->config, volume_grid->config, m_col_data[col_speed_perimeter]->key));
            volume_grid->ori_speed_perimeter = object_grid->speed_perimeter;
            m_grid_data.push_back(volume_grid);
        }
    }
 
    m_data_valid = true;
 
    return;
}

Here is the call graph for this function:

◆ convert_filament_string()

wxString Slic3r::GUI::ObjectGridTable::convert_filament_string	(	int	index,
		wxString &	filament_str )

{
    wxString result_str;
    if (filament_str.find("PLA") !=  wxNOT_FOUND ) {
        //PLA
        result_str = wxString(std::to_string(index+1) + ": PLA");
    }
    else if (filament_str.find("ABS") != wxNOT_FOUND ) {
        //ABS
        result_str = wxString(std::to_string(index+1) + ": ABS");
    }
    else if (filament_str.find("PETG") != wxNOT_FOUND ) {
        //PETG
        result_str= wxString(std::to_string(index+1) + ": PETG");
    }
    else if (filament_str.find("TPU") != wxNOT_FOUND ) {
        //TPU
        result_str = wxString(std::to_string(index+1) + ": TPU");
    }
    else
        result_str = filament_str;
 
    //result_str = "";
    return result_str;
}

Referenced by GetValue().

Here is the caller graph for this function:

◆ enable_reset_all_button()

void Slic3r::GUI::ObjectGridTable::enable_reset_all_button ( bool enable )

{
    //m_panel->m_global_reset->Enable(enable);
}

◆ get_col_count()

int Slic3r::GUI::ObjectGridTable::get_col_count ( )

inline

507{ return m_col_data.size(); }

References m_col_data.

◆ get_color_bitmap()

wxBitmap * Slic3r::GUI::ObjectGridTable::get_color_bitmap ( int color_index )

{
    if (color_index < m_panel->m_color_bitmaps.size())
        return m_panel->m_color_bitmaps[color_index];
    else
        return m_panel->m_color_bitmaps[0];
}

References m_panel.

Referenced by Slic3r::GUI::GridCellComboBoxRenderer::Draw(), and Slic3r::GUI::GridCellFilamentsRenderer::Draw().

Here is the caller graph for this function:

◆ get_grid_col()

ObjectGridCol * Slic3r::GUI::ObjectGridTable::get_grid_col ( int col )

inline

508{ return m_col_data[col]; }

References m_col_data.

Here is the caller graph for this function:

◆ get_grid_row()

ObjectGridRow * Slic3r::GUI::ObjectGridTable::get_grid_row ( int row )

inline

509{ return m_grid_data[row]; }

References m_grid_data.

Here is the caller graph for this function:

◆ get_object_config_value()

template<typename TYPE>

const TYPE * Slic3r::GUI::ObjectGridTable::get_object_config_value	(	const DynamicPrintConfig &	global_config,
		ModelConfig *	obj_config,
		std::string &	config_option )

inline

    {
        if (obj_config->has(config_option))
            return static_cast<const TYPE*>(obj_config->option(config_option));
        else {
            const TYPE* ptr = global_config.option<TYPE>(config_option);
            //todo: how to deal with nullptr
            return ptr;
        }
    }

References get_object_config_value().

Referenced by construct_object_configs(), get_object_config_value(), and reload_object_data().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_row_count()

int Slic3r::GUI::ObjectGridTable::get_row_count ( )

inline

506{ return m_grid_data.size() + 1; }

References m_grid_data.

Referenced by update_row_properties().

Here is the caller graph for this function:

◆ get_undo_bitmap()

wxBitmap & Slic3r::GUI::ObjectGridTable::get_undo_bitmap ( bool selected = false )

{
    return m_panel->m_undo_bitmap;
}

References m_panel.

Referenced by Slic3r::GUI::GridCellIconRenderer::Draw().

Here is the caller graph for this function:

◆ get_volume_config_value()

template<typename TYPE>

const TYPE * Slic3r::GUI::ObjectGridTable::get_volume_config_value	(	const DynamicPrintConfig &	global_config,
		ModelConfig *	obj_config,
		ModelConfig *	volume_config,
		std::string &	config_option )

inline

    {
        if (volume_config->has(config_option))
            return static_cast<const TYPE*>(volume_config->option(config_option));
        else if (obj_config->has(config_option))
            return static_cast<const TYPE*>(obj_config->option(config_option));
        else {
            const TYPE* ptr = global_config.option<TYPE>(config_option);
            //todo: how to deal with nullptr
            return ptr;
        }
    }

References Slic3r::ModelConfig::has(), Slic3r::ConfigBase::option(), and Slic3r::ModelConfig::option().

Referenced by construct_object_configs(), and reload_part_data().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetColLabelValue()

wxString Slic3r::GUI::ObjectGridTable::GetColLabelValue ( int col )

{
    if ( col > (int)(m_colLabels.GetCount()) - 1 )
    {
        // using default label
        //
        return wxGridTableBase::GetColLabelValue( col );
    }
    else
    {
        return m_colLabels[col];
    }
}

References m_colLabels.

◆ GetNumberCols()

int Slic3r::GUI::ObjectGridTable::GetNumberCols ( )

virtual

{
    return m_col_data.size();
}

References m_col_data.

◆ GetNumberRows()

int Slic3r::GUI::ObjectGridTable::GetNumberRows ( )

virtual

{
    return m_grid_data.size() + 1;
}

References m_grid_data.

◆ GetTypeName()

wxString Slic3r::GUI::ObjectGridTable::GetTypeName	(	int	row,
		int	col )

virtual

{
    if (row == 0)
        return wxGRID_VALUE_STRING;
 
    ObjectGridCol* col_object = m_col_data[col];
    ConfigOptionType option_type = col_object->type;
    wxString type_name;
 
    switch (option_type)
    {
        case coString:
            return wxGRID_VALUE_STRING;
        case coBool:
            return wxGRID_VALUE_BOOL;
        case coInt:
            return wxGRID_VALUE_NUMBER;
        case coFloat:
        case coPercent:
            return wxGRID_VALUE_FLOAT;
        case coEnum:
            return wxGRID_VALUE_CHOICE;
        default:
            break;
    }
 
    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(", unknown column");
    return wxEmptyString;
}

References Slic3r::coBool, Slic3r::coEnum, Slic3r::coFloat, Slic3r::coInt, Slic3r::coPercent, Slic3r::coString, m_col_data, and Slic3r::GUI::ObjectGridTable::ObjectGridCol::type.

◆ GetValue()

wxString Slic3r::GUI::ObjectGridTable::GetValue	(	int	row,
		int	col )

virtual

{
    if (!m_data_valid)
        return wxString();
 
    //row 0 always use string type for label
    if (row == 0) {
        switch ((GridColType)col)
        {
            case col_plate_index:
                return "Plate";
                /* case col_assemble_name:
                     return "Module";*/
            case col_name:
                return "Name";
            case col_printable:
                return "Printable";
            case col_filaments:
                return "Filament";
            case col_layer_height:
                return "Layer height";
            case col_wall_loops:
                return "Perimeter";
            case col_fill_density:
                return "Infill density(%)";
            case col_enable_support:
                return "Support";
            case col_brim_type:
                return "Brim";
            case col_speed_perimeter:
                return "Perimeter speed";
            default:
                return wxString();
        }
    }
 
    ObjectGridRow* grid_row = m_grid_data[row - 1];
    ObjectGridCol* grid_col = m_col_data[(GridColType)col];
    if (grid_col->b_for_object && (grid_row->row_type == row_volume))
        return wxString();
 
    ConfigOption& option = (*grid_row)[(GridColType)col];
    if (grid_col->type == coEnum) {
        if (col == col_brim_type) {
            ConfigOptionEnum<BrimType>& option_value = dynamic_cast<ConfigOptionEnum<BrimType>&>(option);
            if (option_value.value < grid_col->choice_count)
               return grid_col->choices[option_value.value];
        }
        else if (col == col_filaments) {
            ConfigOptionInt& option_value = dynamic_cast<ConfigOptionInt&>(option);
            if ((option_value.value - 1) < grid_col->choice_count) {
               //return grid_col->choices[(option_value.value > 0)?option_value.value - 1: 0];
                int index = (option_value.value > 0) ? option_value.value - 1 : 0;
               return convert_filament_string(index, grid_col->choices[index]);
               //return grid_col->choices[index];
            }
        }
    }
    else if (grid_col->type == coBool) {
        ConfigOptionBool& option_value = dynamic_cast<ConfigOptionBool&>(option);
        return option_value.value?"-":"-";
    }
    else if (grid_col->type == coInt) {
        ConfigOptionInt& option_value = dynamic_cast<ConfigOptionInt&>(option);
        return wxString::Format("%d", option_value.value);
    } else if (grid_col->type == coFloat) {
        if (auto option_values = dynamic_cast<ConfigOptionFloatsNullable*>(&option)) {
            return wxString::Format("%.2f", option_values->get_at(0));
        }
        ConfigOptionFloat& option_value = dynamic_cast<ConfigOptionFloat&>(option);
        return wxString::Format("%.2f", option_value.value);
    }
    else if (grid_col->type == coPercent) {
        ConfigOptionPercent& option_value = dynamic_cast<ConfigOptionPercent&>(option);
        return wxString::Format("%.2f", option_value.value);
    }
    else {
        try {
            if (grid_row->row_type == row_volume){
                ConfigOptionString& option_value = dynamic_cast<ConfigOptionString&>(option);
                return GUI::from_u8(std::string("  ") + option_value.value);
            }   
            else {
                if (option.type() == coInt) {
                    ConfigOptionInt& option_value = dynamic_cast<ConfigOptionInt&>(option);
                    return GUI::from_u8(wxString::Format("%d",option_value.value).ToStdString());
                }else {
                    ConfigOptionString& option_value = dynamic_cast<ConfigOptionString&>(option);
                    return GUI::from_u8(option_value.value);
                }
 
            }
        }
        catch(...) {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format("row %1%, col %2%, type %3% ")%row %col %grid_col->type;
            return wxString();
        }
    }
 
    return wxString();
}

References Slic3r::GUI::ObjectGridTable::ObjectGridCol::b_for_object, Slic3r::GUI::ObjectGridTable::ObjectGridCol::choice_count, Slic3r::GUI::ObjectGridTable::ObjectGridCol::choices, Slic3r::coBool, Slic3r::coEnum, Slic3r::coFloat, Slic3r::coInt, col_brim_type, col_enable_support, col_filaments, col_fill_density, col_layer_height, col_name, col_plate_index, col_printable, col_speed_perimeter, col_wall_loops, convert_filament_string(), Slic3r::coPercent, Slic3r::GUI::from_u8(), m_col_data, m_data_valid, m_grid_data, Slic3r::GUI::ObjectGridTable::ObjectGridRow::row_type, row_volume, Slic3r::ConfigOption::type(), Slic3r::GUI::ObjectGridTable::ObjectGridCol::type, and Slic3r::ConfigOptionSingle< T >::value.

Referenced by Slic3r::GUI::GridCellTextEditor::BeginEdit(), Slic3r::GUI::GridCellSupportRenderer::Draw(), and Slic3r::GUI::ObjectGrid::OnKeyDown().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetValueAsBool()

bool Slic3r::GUI::ObjectGridTable::GetValueAsBool	(	int	row,
		int	col )

virtual

{
    if (!m_data_valid)
        return 0;
 
    ObjectGridRow* grid_row = m_grid_data[row - 1];
    ConfigOptionBool &option_value = dynamic_cast<ConfigOptionBool &>((*grid_row)[(GridColType)col]);
    return option_value.getBool();
}

References Slic3r::ConfigOptionBool::getBool(), m_data_valid, and m_grid_data.

Referenced by Slic3r::GUI::ObjectGrid::OnKeyDown().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetValueAsDouble()

double Slic3r::GUI::ObjectGridTable::GetValueAsDouble	(	int	row,
		int	col )

virtual

{
    if (!m_data_valid)
        return 0;
 
    ObjectGridRow* grid_row = m_grid_data[row - 1];
    if (auto option_values = dynamic_cast<ConfigOptionFloatsNullable*>(&(*grid_row)[(GridColType) col])) {
        return (double) option_values->get_at(0);
    }
    ConfigOptionFloat& option_value = dynamic_cast<ConfigOptionFloat&>((*grid_row)[(GridColType) col]);
    return (double) option_value.getFloat();
}

References Slic3r::ConfigOptionFloat::getFloat(), m_data_valid, and m_grid_data.

Here is the call graph for this function:

◆ GetValueAsLong()

long Slic3r::GUI::ObjectGridTable::GetValueAsLong	(	int	row,
		int	col )

virtual

{
    if (!m_data_valid)
        return 0;
 
    ObjectGridRow* grid_row = m_grid_data[row - 1];
    ConfigOptionInt &option_value = dynamic_cast<ConfigOptionInt &>((*grid_row)[(GridColType)col]);
    return (long)option_value.getInt();
}

References Slic3r::ConfigOptionInt::getInt(), m_data_valid, and m_grid_data.

Here is the call graph for this function:

◆ init_cols()

void Slic3r::GUI::ObjectGridTable::init_cols ( ObjectGrid * object_grid )

private

{
    const float font_size = 1.5f * wxGetApp().em_unit();
 
 
    // printable for object
    ObjectGridCol *col = new ObjectGridCol(coBool, "printable", ObjectGridTable::category_all, true, false, true, false, wxALIGN_CENTRE);
    col->size = object_grid->GetTextExtent(L("Printable")).x;
    m_col_data.push_back(col);
 
    // reset icon for printable
    col = new ObjectGridCol(coBool, "printable_reset", ObjectGridTable::category_all, true, true, false, false, wxALIGN_LEFT);
    m_col_data.push_back(col);
 
    //first column for plate_index
    col = new ObjectGridCol(coString, "plate_index", " ", true, false, false, false, wxALIGN_CENTRE); //bool only_object, bool icon, bool edit, bool config
    m_col_data.push_back(col);
 
    //second column for module name
    /*col = new ObjectGridCol(coString, "assemble_name", ObjectGridTable::category_all, true, false, true, false, wxALIGN_CENTRE);
    m_col_data.push_back(col);*/
 
    //3th column: for object/volume name
    col       = new ObjectGridCol(coString, "name", ObjectGridTable::category_all, false, false, true, false, wxALIGN_LEFT);
    //col->size = 200;
    m_col_data.push_back(col);
 
    //object/volume extruder_id
    col = new ObjectGridCol(coEnum, "extruder", ObjectGridTable::category_all, false, false, true, true, wxALIGN_CENTRE);
    col->size = 128;
    //the spec now guarantees vectors store their elements contiguously
    col->choices.assign(m_panel->m_filaments_name.begin(), m_panel->m_filaments_name.end());
    col->choice_count = m_panel->m_filaments_count;
    m_col_data.push_back(col);
 
    //reset icon for extruder_id
    col = new ObjectGridCol(coString, "extruder_reset", ObjectGridTable::category_all, false, false, false, false, wxALIGN_CENTRE);
    m_col_data.push_back(col);
 
    //object layer height
    col       = new ObjectGridCol(coFloat, "layer_height", L("Quality"), true, false, true, true, wxALIGN_LEFT);
    col->size = object_grid->GetTextExtent(L("Layer height")).x - 28;
    m_col_data.push_back(col);
 
    //reset icon for extruder_id
    col = new ObjectGridCol(coFloat, "layer_height_reset", L("Quality"), true, true, false, false, wxALIGN_LEFT);
    m_col_data.push_back(col);
 
    //object/volume perimeters
    col       = new ObjectGridCol(coInt, "wall_loops", L("Strength"), false, false, true, true, wxALIGN_CENTRE);
    col->size = object_grid->GetTextExtent(L("Wall loops")).x;
    m_col_data.push_back(col);
 
    //reset icon for perimeters
    col = new ObjectGridCol(coInt, "wall_loops_reset", L("Strength"), false, true, false, false, wxALIGN_LEFT);
    m_col_data.push_back(col);
 
    //object/volume fill density
    col = new ObjectGridCol(coPercent, "sparse_infill_density", L("Strength"), false, false, true, true, wxALIGN_CENTRE);
    col->size = object_grid->GetTextExtent(L("Infill density(%)")).x;
    m_col_data.push_back(col);
 
    //reset icon for fill density
    col = new ObjectGridCol(coPercent, "fill_density_reset", L("Strength"), false, true, false, false, wxALIGN_LEFT);
    m_col_data.push_back(col);
 
    //support material
    col = new ObjectGridCol(coBool, "enable_support", L("Support"), true, false, true, true, wxALIGN_CENTRE);
    col->size = object_grid->GetTextExtent(L("Support")).x;
    m_col_data.push_back(col);
 
    //reset icon for support material
    col = new ObjectGridCol(coBool, "support_reset", L("Support"), true, true, false, false, wxALIGN_CENTRE);
    m_col_data.push_back(col);
 
    //Bed Adhesion
    col               = new ObjectGridCol(coEnum, "brim_type", L("Support"), true, false, true, true, wxALIGN_LEFT);
    col->size = object_grid->GetTextExtent(L("Auto Brim")).x + 8; //add 8 for border
    col->choices.Add(_L("Auto"));
    col->choices.Add(_L("Mouse ear"));
    col->choices.Add(_L("Painted"));
    col->choices.Add(_L("Outer brim only"));
    col->choices.Add(_L("Inner brim only"));
    col->choices.Add(_L("Outer and inner brim"));
    col->choices.Add(_L("No-brim"));
    col->choice_count = col->choices.size();
    m_col_data.push_back(col);
 
    //reset icon for Bed Adhesion
    col = new ObjectGridCol(coEnum, "brim_type_reset", L("Support"), true, true, false, false, wxALIGN_LEFT);
    m_col_data.push_back(col);
    
    // todo mutli_extruders:
    //object/volume speed
    col       = new ObjectGridCol(coFloat, "outer_wall_speed", L("Speed"), false, false, true, true, wxALIGN_LEFT);
    col->size = object_grid->GetTextExtent(L("Outer wall speed")).x;
    m_col_data.push_back(col);
 
    //reset icon for speed
    col = new ObjectGridCol(coFloat, "inner_wall_speed_reset", L("Speed"), false, true, false, false, wxALIGN_LEFT);
    m_col_data.push_back(col);
 
    return;
}

References _L, category_all, Slic3r::GUI::ObjectGridTable::ObjectGridCol::choice_count, Slic3r::GUI::ObjectGridTable::ObjectGridCol::choices, Slic3r::coBool, Slic3r::coEnum, Slic3r::coFloat, Slic3r::coInt, Slic3r::coPercent, Slic3r::coString, L, m_col_data, m_panel, and Slic3r::GUI::ObjectGridTable::ObjectGridCol::size.

Referenced by construct_object_configs().

Here is the caller graph for this function:

◆ IsEmptyCell()

bool Slic3r::GUI::ObjectGridTable::IsEmptyCell	(	int	row,
		int	col )

virtual

{
    if (row == 0)
        return false;
 
    ObjectGridCol* col_object = m_col_data[col];
    ObjectGridRow* row_object = m_grid_data[row - 1];
 
    if (col_object->b_for_object && (row_object->row_type == row_volume))
        return true;
 
    return false;
}

References Slic3r::GUI::ObjectGridTable::ObjectGridCol::b_for_object, m_col_data, m_grid_data, row_object, and row_volume.

◆ OnCellLeftClick()

bool Slic3r::GUI::ObjectGridTable::OnCellLeftClick	(	int	row,
		int	col,
		ConfigOptionType &	type )

{
    bool consumed = false;
 
    if (row == 0) {
        sort_by_col(col);
    } else if (col >= col_printable_reset) {
        ObjectGridRow *grid_row   = m_grid_data[row - 1];
        ObjectGridCol* grid_col = m_col_data[col];
        ObjectGridCol* grid_col_2 = m_col_data[col - 1];
 
        if (grid_col->b_icon) {
            ConfigOption& orig_option = (*grid_row)[(GridColType)col];
            ConfigOption& cur_option = (*grid_row)[(GridColType)(col-1)];
            //reset the value to original one
            if (cur_option != orig_option) {
                cur_option.set(&orig_option);
                if (grid_col_2->b_from_config) {
                    if (col == col_filaments_reset) {
                        update_filament_to_config(grid_row->config, grid_col_2->key, cur_option, orig_option, (grid_row->row_type == row_object));
                        update_volume_values_from_object(row, col-1);
                    }
                    else
                        update_value_to_config(grid_row->config, grid_col_2->key, cur_option, orig_option);
                    ObjectVolumeID object_volume_id;
                    object_volume_id.object = m_panel->m_model->objects[grid_row->object_id];
                    object_volume_id.volume = (grid_row->row_type == row_object) ? nullptr : object_volume_id.object->volumes[grid_row->volume_id];
                    if (col == col_filaments_reset)
                        wxGetApp().obj_list()->update_filament_values_for_items(m_panel->m_filaments_count);
                    else
                        wxGetApp().obj_list()->object_config_options_changed(object_volume_id);
 
                    //update the right side setting list
                    bool is_object = (grid_row->row_type == row_object);
                    ModelObject* object = m_panel->m_model->objects[grid_row->object_id];
                    m_panel->m_side_window->Freeze();
                    m_panel->m_object_settings->ValueChanged(row, is_object, object, grid_row->config, grid_col_2->category, grid_col_2->key);
                    m_panel->m_side_window->Thaw();
                    //m_panel->m_plater->update();
                }
                else {
                    update_value_to_object(m_panel->m_model, grid_row, col - 1);
                }
                m_panel->m_object_grid->ForceRefresh();
            }
            consumed = true;
        }
        else
            type = grid_col->type;
    }
    return consumed;
}

Here is the call graph for this function:

◆ OnCellValueChanged()

void Slic3r::GUI::ObjectGridTable::OnCellValueChanged	(	int	row,
		int	col )

{
    if (row == 0) {
        //skip it
    }
    else if (col <= (int)col_filaments_reset) {
        //skip it
    }
    else {
        ObjectGridRow* grid_row = m_grid_data[row - 1];
        ObjectGridCol* grid_col = m_col_data[col];
        bool is_object = (grid_row->row_type == row_object);
        ModelObject* object = m_panel->m_model->objects[grid_row->object_id];
 
        m_panel->m_side_window->Freeze();
 
        m_panel->m_object_settings->ValueChanged(row, is_object, object, grid_row->config, grid_col->category, grid_col->key);
 
        m_panel->m_side_window->Thaw();
        //update volume cell
        /*if (is_object) {
            int next_row = row + 1;
            DynamicPrintConfig&  global_config   = wxGetApp().preset_bundle->prints.get_edited_preset().config;
            while ((next_row - 1) < m_grid_data.size())
            {
                ObjectGridRow* part_row = m_grid_data[next_row - 1];
                if (part_row->row_type == row_volume) {
                    reload_part_data(part_row, grid_row, grid_col->category, global_config);
                    next_row++;
                }
                else
                    break;
            }
        }*/
        //obj_list->update_extruder_values_for_items(m_panel->m_filaments_count);
        if (grid_col->b_from_config) {
            if (col != col_filaments) {//for col_filaments, no cellvaluechanged triggered
                ObjectVolumeID object_volume_id;
                object_volume_id.object = object;
                object_volume_id.volume = is_object ? nullptr : object->volumes[grid_row->volume_id];
                wxGetApp().obj_list()->object_config_options_changed(object_volume_id);
                //m_panel->m_plater->update();
            }
        }
    }
}

Referenced by Slic3r::GUI::ObjectGrid::paste_data().

Here is the caller graph for this function:

◆ OnRangeSelected()

void Slic3r::GUI::ObjectGridTable::OnRangeSelected	(	int	row,
		int	col,
		int	row_count,
		int	col_count )

2672{

2673}

◆ OnSelectCell()

void Slic3r::GUI::ObjectGridTable::OnSelectCell	(	int	row,
		int	col )

{
    m_selected_cells.clear();
    if (!m_panel->m_side_window)
        return;
    m_panel->m_side_window->Freeze();
    if (row == 0 || col == col_filaments) {
        m_panel->m_object_settings->UpdateAndShowRow(row, false, false, false, nullptr, nullptr, std::string());
    }
    else {
        ObjectGridRow* grid_row = m_grid_data[row - 1];
        ObjectGridCol* grid_col = m_col_data[col];
        bool is_object = (grid_row->row_type == row_object);
        ModelObject* object = m_panel->m_model->objects[grid_row->object_id];
 
        //m_panel->m_object_settings->get_og()->set_name(GUI::from_u8(grid_row->name.value));
        //m_panel->m_page_text->SetLabel(GUI::from_u8(grid_row->name.value));
        m_panel->m_object_settings->UpdateAndShowRow(row, true, is_object, false, object, grid_row->config, grid_col->category);
 
        std::vector<ObjectVolumeID> object_volume_ids;
        ObjectVolumeID object_volume_id;
        object_volume_id.object = object;
        object_volume_id.volume = (grid_row->row_type == row_object)?nullptr:object->volumes[grid_row->volume_id];
        object_volume_ids.push_back(object_volume_id);
        //disable multiple selection notify, only notify one selected item to object list
        /*wxGridCellCoordsArray cell_array = m_panel->m_object_grid->GetSelectedCells();
        int count = cell_array.size();
        if (count == 0) {
            ObjectVolumeID object_volume_id;
            object_volume_id.object = object;
            object_volume_id.volume = (grid_row->row_type == row_object)?nullptr:object->volumes[grid_row->volume_id];
            object_volume_ids.push_back(object_volume_id);
 
            wxGridCellCoords cell_coord(row, col);
            m_selected_cells.push_back(cell_coord);
        }
        else {
            while (count > 0) {
                int cel_row = cell_array[count-1].GetRow();
                int cel_col = cell_array[count-1].GetCol();
                ObjectGridRow* grid_data = m_grid_data[cel_row - 1];
                object = m_panel->m_model->objects[grid_data->object_id];
                ObjectVolumeID object_volume_id;
                object_volume_id.object = object;
                object_volume_id.volume = (grid_data->row_type == row_object)?nullptr:object->volumes[grid_data->volume_id];
                object_volume_ids.push_back(object_volume_id);
                count --;
 
                wxGridCellCoords cell_coord(cel_row, cel_col);
                m_selected_cells.push_back(cell_coord);
            }
        }*/
 
        wxGetApp().obj_list()->select_items(object_volume_ids);
    }
    m_panel->m_side_window->Layout();
    //m_panel->m_side_window->ShowScrollbars(wxSHOW_SB_NEVER, wxSHOW_SB_ALWAYS);
    m_panel->m_side_window->Thaw();
    m_panel->Layout();
    m_current_row = row;
    m_current_col = col;
}

References Slic3r::GUI::ObjectGridTable::ObjectGridCol::category, col_filaments, Slic3r::GUI::ObjectGridTable::ObjectGridRow::config, m_col_data, m_current_col, m_current_row, m_grid_data, m_panel, m_selected_cells, Slic3r::GUI::ObjectVolumeID::object, Slic3r::GUI::ObjectGridTable::ObjectGridRow::object_id, row_object, Slic3r::GUI::ObjectGridTable::ObjectGridRow::row_type, Slic3r::GUI::ObjectVolumeID::volume, and Slic3r::GUI::ObjectGridTable::ObjectGridRow::volume_id.

◆ release_object_configs()

void Slic3r::GUI::ObjectGridTable::release_object_configs ( )

{
    if (m_grid_data.size() > 0)
    {
        for (int i = 0; i < m_grid_data.size(); i ++)
        {
            delete m_grid_data[i];
        }
        m_grid_data.clear();
    }
 
    if (m_col_data.size() > 0)
    {
        for (int i = 0; i < m_col_data.size(); i ++)
        {
            delete m_col_data[i];
        }
        m_col_data.clear();
    }
 
    m_data_valid = false;
 
    return;
}

References m_col_data, m_data_valid, and m_grid_data.

Referenced by construct_object_configs().

Here is the caller graph for this function:

◆ reload_cell_data()

void Slic3r::GUI::ObjectGridTable::reload_cell_data	(	int	row,
		const std::string &	category )

{
    if (row == 0)
        return;
    ObjectGridRow* grid_row = m_grid_data[row - 1];
    DynamicPrintConfig&  global_config   = wxGetApp().preset_bundle->prints.get_edited_preset().config;
 
    if (grid_row->row_type == row_object) {
        reload_object_data(grid_row, category, global_config);
 
        int next_row = row + 1;
        while ((next_row - 1) < m_grid_data.size())
        {
            ObjectGridRow* part_row = m_grid_data[next_row - 1];
            if (part_row->row_type == row_volume) {
                reload_part_data(part_row, grid_row, category, global_config);
                next_row++;
            }
            else
                break;
        }
    }
    else {
        int next_row = row - 1;
        ObjectGridRow* object_row = m_grid_data[next_row - 1];
        while (object_row->row_type == row_volume)
        {
            next_row --;
            object_row = m_grid_data[next_row - 1];
        }
        reload_part_data(grid_row, object_row, category, global_config);
    }
    m_panel->m_object_grid->ForceRefresh();
 
    ObjectVolumeID object_volume_id;
    object_volume_id.object = m_panel->m_model->objects[grid_row->object_id];
    object_volume_id.volume = (grid_row->row_type == row_object)?nullptr:object_volume_id.object->volumes[grid_row->volume_id];
    wxGetApp().obj_list()->object_config_options_changed(object_volume_id);
    if (object_volume_id.volume)
        dynamic_cast<TabPrintModel*>(wxGetApp().get_model_tab(true))->update_model_config();
    else
        dynamic_cast<TabPrintModel*>(wxGetApp().get_model_tab())->update_model_config();
    //m_panel->m_plater->update();
}

References m_grid_data, m_panel, Slic3r::GUI::ObjectVolumeID::object, Slic3r::GUI::ObjectGridTable::ObjectGridRow::object_id, reload_object_data(), reload_part_data(), row_object, Slic3r::GUI::ObjectGridTable::ObjectGridRow::row_type, row_volume, Slic3r::GUI::ObjectVolumeID::volume, Slic3r::GUI::ObjectGridTable::ObjectGridRow::volume_id, and Slic3r::ModelObject::volumes.

Here is the call graph for this function:

◆ reload_object_data()

void Slic3r::GUI::ObjectGridTable::reload_object_data	(	ObjectGridRow *	grid_row,
		const std::string &	category,
		DynamicPrintConfig &	global_config )

{
    if (category == ObjectGridTable::category_all) {
        grid_row->layer_height = *(get_object_config_value<ConfigOptionFloat>(global_config, grid_row->config, m_col_data[col_layer_height]->key));
        grid_row->ori_layer_height = *(global_config.option<ConfigOptionFloat>(m_col_data[col_layer_height]->key));
        grid_row->wall_loops = *(get_object_config_value<ConfigOptionInt>(global_config, grid_row->config, m_col_data[col_wall_loops]->key));
        grid_row->ori_wall_loops = *(global_config.option<ConfigOptionInt>(m_col_data[col_wall_loops]->key));
        grid_row->sparse_infill_density = *(get_object_config_value<ConfigOptionPercent>(global_config, grid_row->config, m_col_data[col_fill_density]->key));
        grid_row->ori_fill_density = *(global_config.option<ConfigOptionPercent>(m_col_data[col_fill_density]->key));
        grid_row->enable_support = *(get_object_config_value<ConfigOptionBool>(global_config, grid_row->config, m_col_data[col_enable_support]->key));
        grid_row->ori_enable_support = *(global_config.option<ConfigOptionBool>(m_col_data[col_enable_support]->key));
        grid_row->brim_type = *(get_object_config_value<ConfigOptionEnum<BrimType>>(global_config, grid_row->config, m_col_data[col_brim_type]->key));
        grid_row->ori_brim_type = *(global_config.option<ConfigOptionEnum<BrimType>>(m_col_data[col_brim_type]->key));
        grid_row->speed_perimeter       = *(get_object_config_value<ConfigOptionFloatsNullable>(global_config, grid_row->config, m_col_data[col_speed_perimeter]->key));
        grid_row->ori_speed_perimeter   = *(global_config.option<ConfigOptionFloatsNullable>(m_col_data[col_speed_perimeter]->key));
    }
    else if (category == L("Quality")) {
        grid_row->layer_height = *(get_object_config_value<ConfigOptionFloat>(global_config, grid_row->config, m_col_data[col_layer_height]->key));
        grid_row->ori_layer_height = *(global_config.option<ConfigOptionFloat>(m_col_data[col_layer_height]->key));
    }
    else if (category == L("Strength")) {
        grid_row->wall_loops = *(get_object_config_value<ConfigOptionInt>(global_config, grid_row->config, m_col_data[col_wall_loops]->key));
        grid_row->ori_wall_loops = *(global_config.option<ConfigOptionInt>(m_col_data[col_wall_loops]->key));
 
        grid_row->sparse_infill_density = *(get_object_config_value<ConfigOptionPercent>(global_config, grid_row->config, m_col_data[col_fill_density]->key));
        grid_row->ori_fill_density      = *(global_config.option<ConfigOptionPercent>(m_col_data[col_fill_density]->key));
    }
    else if (category == L("Support")) {
        grid_row->enable_support = *(get_object_config_value<ConfigOptionBool>(global_config, grid_row->config, m_col_data[col_enable_support]->key));
        grid_row->ori_enable_support = *(global_config.option<ConfigOptionBool>(m_col_data[col_enable_support]->key));
 
        grid_row->brim_type = *(get_object_config_value<ConfigOptionEnum<BrimType>>(global_config, grid_row->config, m_col_data[col_brim_type]->key));
        grid_row->ori_brim_type = *(global_config.option<ConfigOptionEnum<BrimType>>(m_col_data[col_brim_type]->key));
    }
    else if (category == L("Speed")) {
        grid_row->speed_perimeter = *(get_object_config_value<ConfigOptionFloatsNullable>(global_config, grid_row->config, m_col_data[col_speed_perimeter]->key));
        grid_row->ori_speed_perimeter = *(global_config.option<ConfigOptionFloatsNullable>(m_col_data[col_speed_perimeter]->key));
    }
}

Referenced by reload_cell_data().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reload_part_data()

void Slic3r::GUI::ObjectGridTable::reload_part_data	(	ObjectGridRow *	volume_row,
		ObjectGridRow *	object_row,
		const std::string &	category,
		DynamicPrintConfig &	global_config )

{
    if (category == ObjectGridTable::category_all) {
        volume_row->layer_height = *(get_volume_config_value<ConfigOptionFloat>(global_config, object_row->config, volume_row->config, m_col_data[col_layer_height]->key));
        volume_row->ori_layer_height = object_row->layer_height;
        volume_row->wall_loops = *(get_volume_config_value<ConfigOptionInt>(global_config, object_row->config, volume_row->config, m_col_data[col_wall_loops]->key));
        volume_row->ori_wall_loops = object_row->wall_loops;
        volume_row->sparse_infill_density = *(get_volume_config_value<ConfigOptionPercent>(global_config, object_row->config, volume_row->config, m_col_data[col_fill_density]->key));
        volume_row->ori_fill_density = object_row->sparse_infill_density;
        volume_row->enable_support = *(get_volume_config_value<ConfigOptionBool>(global_config, object_row->config, volume_row->config, m_col_data[col_enable_support]->key));
        volume_row->ori_enable_support = object_row->enable_support;
        volume_row->brim_type = *(get_volume_config_value<ConfigOptionEnum<BrimType>>(global_config, object_row->config, volume_row->config, m_col_data[col_brim_type]->key));
        volume_row->ori_brim_type = object_row->brim_type;
        volume_row->speed_perimeter = *(get_volume_config_value<ConfigOptionFloatsNullable>(global_config, object_row->config, volume_row->config, m_col_data[col_speed_perimeter]->key));
        volume_row->ori_speed_perimeter = object_row->speed_perimeter;
    }
    else if (category == L("Quality")) {
        volume_row->layer_height = *(get_volume_config_value<ConfigOptionFloat>(global_config, object_row->config, volume_row->config, m_col_data[col_layer_height]->key));
        if (volume_row->layer_height == object_row->layer_height) {
            volume_row->config->erase(m_col_data[col_layer_height]->key);
        }
        volume_row->ori_layer_height = object_row->layer_height;
    }
    else if (category == L("Strength")) {
        volume_row->wall_loops = *(get_volume_config_value<ConfigOptionInt>(global_config, object_row->config, volume_row->config, m_col_data[col_wall_loops]->key));
        if (volume_row->wall_loops == object_row->wall_loops) {
            volume_row->config->erase(m_col_data[col_wall_loops]->key);
        }
        volume_row->ori_wall_loops        = object_row->wall_loops;
 
        volume_row->sparse_infill_density = *(get_volume_config_value<ConfigOptionPercent>(global_config, object_row->config, volume_row->config, m_col_data[col_fill_density]->key));
        if (volume_row->sparse_infill_density == object_row->sparse_infill_density) {
            volume_row->config->erase(m_col_data[col_fill_density]->key);
        }
        volume_row->ori_fill_density = object_row->sparse_infill_density;
    }
    else if (category == L("Support")) {
        volume_row->enable_support = *(get_volume_config_value<ConfigOptionBool>(global_config, object_row->config, volume_row->config, m_col_data[col_enable_support]->key));
        if (volume_row->enable_support == object_row->enable_support) {
            volume_row->config->erase(m_col_data[col_enable_support]->key);
        }
        volume_row->ori_enable_support = object_row->enable_support;
 
        volume_row->brim_type = *(get_volume_config_value<ConfigOptionEnum<BrimType>>(global_config, object_row->config, volume_row->config, m_col_data[col_brim_type]->key));
        if (volume_row->brim_type == object_row->brim_type) {
            volume_row->config->erase(m_col_data[col_brim_type]->key);
        }
        volume_row->ori_brim_type = object_row->brim_type;
    }
    else if (category == L("Speed")) {
        volume_row->speed_perimeter = *(get_volume_config_value<ConfigOptionFloatsNullable>(global_config, object_row->config, volume_row->config, m_col_data[col_speed_perimeter]->key));
        if (volume_row->speed_perimeter == object_row->speed_perimeter) {
            volume_row->config->erase(m_col_data[col_speed_perimeter]->key);
        }
        volume_row->ori_speed_perimeter = object_row->speed_perimeter;
    }
}

Referenced by reload_cell_data(), and update_volume_values_from_object().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ resetValuesInCurrentCell()

void Slic3r::GUI::ObjectGridTable::resetValuesInCurrentCell ( wxEvent & WXUNUSEDevent )

{
    //return for the first row
    if (m_current_row <= 0)
        return;
 
    ObjectGridRow* grid_row = m_grid_data[m_current_row - 1];
    ObjectGridCol* grid_col = m_col_data[m_current_col];
    bool is_object = (grid_row->row_type == row_object);
    ModelObject* object = m_panel->m_model->objects[grid_row->object_id];
 
    m_panel->resetAllValuesInSideWindow(m_current_row, is_object, object, grid_row->config, grid_col->category);
}

References Slic3r::GUI::ObjectGridTable::ObjectGridCol::category, Slic3r::GUI::ObjectGridTable::ObjectGridRow::config, m_col_data, m_current_col, m_current_row, m_grid_data, m_panel, Slic3r::GUI::ObjectGridTable::ObjectGridRow::object_id, row_object, and Slic3r::GUI::ObjectGridTable::ObjectGridRow::row_type.

◆ SetColLabelValue()

void Slic3r::GUI::ObjectGridTable::SetColLabelValue	(	int	col,
		const wxString &	value )

{
    if ( col > (int)(m_colLabels.GetCount()) - 1 )
    {
        int n = m_colLabels.GetCount();
        int i;
 
        for ( i = n; i <= col; i++ )
        {
            m_colLabels.Add( wxGridTableBase::GetColLabelValue(i) );
        }
    }
 
    m_colLabels[col] = value;
}

References m_colLabels.

◆ SetSelection()

void Slic3r::GUI::ObjectGridTable::SetSelection	(	int	object_id,
		int	volume_id )

{
    BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(", set selection to object %1% part %2%") %object_id %volume_id;
    //invalid object, skip
    if ((object_id == -1)&&(volume_id == -1))
        return;
 
    for (int index = 0; index <  m_grid_data.size(); index++)
    {
        ObjectGridRow* row = m_grid_data[index];
        if (row->object_id == object_id) {
            if ((volume_id == -1) || ((volume_id == row->volume_id)&&(row->row_type == row_volume))) {
                m_panel->m_object_grid->SelectRow(index+1);
                m_panel->m_object_grid->MakeCellVisible(index + 1, 0);
                BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(", found row %1%") %index;
                break;
            }
        }
    }
    BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(", can not find row");
}

References m_grid_data, m_panel, Slic3r::GUI::ObjectGridTable::ObjectGridRow::object_id, Slic3r::GUI::ObjectGridTable::ObjectGridRow::row_type, row_volume, and Slic3r::GUI::ObjectGridTable::ObjectGridRow::volume_id.

◆ SetValue()

void Slic3r::GUI::ObjectGridTable::SetValue	(	int	row,
		int	col,
		const wxString &	value )

virtual

{
    if (row == 0)
        return;
    ObjectGridRow* grid_row = m_grid_data[row - 1];
    ObjectGridCol* grid_col = m_col_data[col];
    ObjectList* obj_list = wxGetApp().obj_list();
    if (grid_col->type == coEnum) {
        int enum_value = 0;
        for (int i = 0; i < grid_col->choice_count; i++)
        {
            if (grid_col->choices[i] == value) {
                enum_value = i;
                break;
            }
            else if ((col == col_filaments)&&(value.substr(0,2) == grid_col->choices[i].substr(0,2))){
                enum_value = i;
                break;
            }
        }
        if (col == col_brim_type) {
            ConfigOptionEnum<BrimType>& option_value = dynamic_cast<ConfigOptionEnum<BrimType>&>((*grid_row)[(GridColType)col]);
            ConfigOptionEnum<BrimType>& option_ori_value = dynamic_cast<ConfigOptionEnum<BrimType>&>((*grid_row)[(GridColType)(col + 1)]);
 
            option_value.value = (BrimType)enum_value;
            update_value_to_config(grid_row->config, grid_col->key, option_value, option_ori_value);
        }
        else if (col == col_filaments) {
            ConfigOptionInt& option_value = dynamic_cast<ConfigOptionInt&>((*grid_row)[(GridColType)col]);
            ConfigOptionInt& option_ori_value = dynamic_cast<ConfigOptionInt&>((*grid_row)[(GridColType)(col + 1)]);
 
            option_value.value = enum_value + 1;
            update_filament_to_config(grid_row->config, grid_col->key, option_value, option_ori_value, (grid_row->row_type == row_object));
            update_volume_values_from_object(row, col);
            wxGetApp().obj_list()->update_filament_values_for_items(m_panel->m_filaments_count);
            //m_panel->m_plater->update();
        }
    }
    else if (grid_col->type == coBool) {
        ConfigOptionBool &option_value = dynamic_cast<ConfigOptionBool &>((*grid_row)[(GridColType)col]);
        ConfigOptionBool &option_ori_value = dynamic_cast<ConfigOptionBool &>((*grid_row)[(GridColType)(col+1)]);
 
        option_value.value = (wxAtoi(value) == 1)?true:false;
 
        if (grid_col->b_from_config) {
            update_value_to_config(grid_row->config, grid_col->key, option_value, option_ori_value);
        }
        else {
            update_value_to_object(m_panel->m_model, grid_row, col);
        }
    } else if (grid_col->type == coFloat) {
        if (auto option_values = dynamic_cast<ConfigOptionFloatsNullable*>(&(*grid_row)[(GridColType) col])) {
            ConfigOptionFloatsNullable& option_ori_values = dynamic_cast<ConfigOptionFloatsNullable&>((*grid_row)[(GridColType) (col + 1)]);
 
            double double_value;
            value.ToDouble(&double_value);
            option_values->values.at(0) = (float) double_value;
 
            update_value_to_config(grid_row->config, grid_col->key, *option_values, option_ori_values);
        } else {
            ConfigOptionFloat& option_value     = dynamic_cast<ConfigOptionFloat&>((*grid_row)[(GridColType) col]);
            ConfigOptionFloat& option_ori_value = dynamic_cast<ConfigOptionFloat&>((*grid_row)[(GridColType) (col + 1)]);
 
            double double_value;
            value.ToDouble(&double_value);
            option_value.value = (float) double_value;
 
            update_value_to_config(grid_row->config, grid_col->key, option_value, option_ori_value);
        }
    }
    else if (grid_col->type == coInt) {
        ConfigOptionInt &option_value = dynamic_cast<ConfigOptionInt &>((*grid_row)[(GridColType)col]);
        ConfigOptionInt &option_ori_value = dynamic_cast<ConfigOptionInt &>((*grid_row)[(GridColType)(col+1)]);
        long  int_value;
        value.ToLong(&int_value);
 
        option_value.value = (int) int_value;
        update_value_to_config(grid_row->config, grid_col->key, option_value, option_ori_value);
    }
    else if (grid_col->type == coPercent) {
        double  double_value;
        value.ToDouble(&double_value);
        if ((double_value > 100.f) || (double_value < 0.f))
            return;
        ConfigOptionFloat &option_value = dynamic_cast<ConfigOptionFloat &>((*grid_row)[(GridColType)col]);
        ConfigOptionFloat &option_ori_value = dynamic_cast<ConfigOptionFloat &>((*grid_row)[(GridColType)(col+1)]);
 
        option_value.value = (float)double_value;
 
        update_value_to_config(grid_row->config, grid_col->key, option_value, option_ori_value);
    }
    else {
        if (grid_col->b_from_config) {
            ConfigOptionString& option_value = dynamic_cast<ConfigOptionString&>((*grid_row)[(GridColType)col]);
            ConfigOptionString& option_ori_value = dynamic_cast<ConfigOptionString&>((*grid_row)[(GridColType)(col + 1)]);
 
            option_value.value = into_u8(value);
            update_value_to_config(grid_row->config, grid_col->key, option_value, option_ori_value);
        }
        else {
            ConfigOptionString& option_value = dynamic_cast<ConfigOptionString&>((*grid_row)[(GridColType)col]);
 
            if (grid_row->row_type == row_volume) {
                //std::string new_value = value.ToStdString();
                std::string new_value = into_u8(value);
                size_t pos = new_value.find_first_not_of(' ');
                if (pos > 0)
                    new_value.erase(0, pos);
                option_value.value = new_value;
            }
            else
                option_value.value = into_u8(value);
            update_value_to_object(m_panel->m_model, grid_row, col);
        }
    }
}

References Slic3r::GUI::ObjectGridTable::ObjectGridCol::b_from_config, Slic3r::GUI::ObjectGridTable::ObjectGridCol::choice_count, Slic3r::GUI::ObjectGridTable::ObjectGridCol::choices, Slic3r::coBool, Slic3r::coEnum, Slic3r::coFloat, Slic3r::coInt, col_brim_type, col_filaments, Slic3r::GUI::ObjectGridTable::ObjectGridRow::config, Slic3r::coPercent, Slic3r::GUI::into_u8(), Slic3r::GUI::ObjectGridTable::ObjectGridCol::key, m_col_data, m_grid_data, m_panel, Slic3r::GUI::obj_list(), row_object, Slic3r::GUI::ObjectGridTable::ObjectGridRow::row_type, row_volume, Slic3r::GUI::ObjectGridTable::ObjectGridCol::type, update_filament_to_config(), update_value_to_config(), update_value_to_object(), update_volume_values_from_object(), and Slic3r::ConfigOptionSingle< T >::value.

Referenced by Slic3r::GUI::GridCellChoiceEditor::DoActivate(), Slic3r::GUI::GridCellFilamentsEditor::DoActivate(), and Slic3r::GUI::ObjectGrid::paste_data().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetValueAsBool()

void Slic3r::GUI::ObjectGridTable::SetValueAsBool	(	int	row,
		int	col,
		bool	value )

virtual

{
    ObjectGridRow* grid_row = m_grid_data[row - 1];
    ObjectGridCol* grid_col = m_col_data[col];
    ConfigOptionBool &option_value = dynamic_cast<ConfigOptionBool &>((*grid_row)[(GridColType)col]);
    ConfigOptionBool &option_ori_value = dynamic_cast<ConfigOptionBool &>((*grid_row)[(GridColType)(col+1)]);
 
    option_value.value = (int) value;
 
    if (grid_col->b_from_config) {
        update_value_to_config(grid_row->config, grid_col->key, option_value, option_ori_value);
    }
    else {
        update_value_to_object(m_panel->m_model, grid_row, col);
    }
    m_panel->m_object_grid->ForceRefresh();
 
    return;
}

References Slic3r::GUI::ObjectGridTable::ObjectGridCol::b_from_config, Slic3r::GUI::ObjectGridTable::ObjectGridRow::config, Slic3r::GUI::ObjectGridTable::ObjectGridCol::key, m_col_data, m_grid_data, m_panel, update_value_to_config(), update_value_to_object(), and Slic3r::ConfigOptionSingle< T >::value.

Here is the call graph for this function:

◆ SetValueAsDouble()

void Slic3r::GUI::ObjectGridTable::SetValueAsDouble	(	int	row,
		int	col,
		double	value )

virtual

{
    ObjectGridRow* grid_row = m_grid_data[row - 1];
    ObjectGridCol* grid_col = m_col_data[col];
 
    if (grid_col->type == coPercent) {
        if ((value > 100.f) || (value < 0.f))
            return;
    }
 
    if (auto option_values = dynamic_cast<ConfigOptionFloatsNullable *>(&(*grid_row)[(GridColType) col])) {
        ConfigOptionFloatsNullable &option_ori_values = dynamic_cast<ConfigOptionFloatsNullable &>((*grid_row)[(GridColType) (col + 1)]);
 
        option_values->values.at(0) = (float) value;
 
        update_value_to_config(grid_row->config, grid_col->key, *option_values, option_ori_values);
 
        return;
    }
 
    ConfigOptionFloat &option_value = dynamic_cast<ConfigOptionFloat &>((*grid_row)[(GridColType)col]);
    ConfigOptionFloat &option_ori_value = dynamic_cast<ConfigOptionFloat &>((*grid_row)[(GridColType)(col+1)]);
 
    option_value.value = (float)value;
 
    update_value_to_config(grid_row->config, grid_col->key, option_value, option_ori_value);
 
    return;
}

References Slic3r::GUI::ObjectGridTable::ObjectGridRow::config, Slic3r::coPercent, Slic3r::GUI::ObjectGridTable::ObjectGridCol::key, m_col_data, m_grid_data, Slic3r::GUI::ObjectGridTable::ObjectGridCol::type, update_value_to_config(), and Slic3r::ConfigOptionSingle< T >::value.

Here is the call graph for this function:

◆ SetValueAsLong()

void Slic3r::GUI::ObjectGridTable::SetValueAsLong	(	int	row,
		int	col,
		long	value )

virtual

{
    ObjectGridRow* grid_row = m_grid_data[row - 1];
    ObjectGridCol* grid_col = m_col_data[col];
    ConfigOptionInt &option_value = dynamic_cast<ConfigOptionInt &>((*grid_row)[(GridColType)col]);
    ConfigOptionInt &option_ori_value = dynamic_cast<ConfigOptionInt &>((*grid_row)[(GridColType)(col+1)]);
 
    option_value.value = (int) value;
    update_value_to_config(grid_row->config, grid_col->key, option_value, option_ori_value);
 
    return;
}

References Slic3r::GUI::ObjectGridTable::ObjectGridRow::config, Slic3r::GUI::ObjectGridTable::ObjectGridCol::key, m_col_data, m_grid_data, update_value_to_config(), and Slic3r::ConfigOptionSingle< T >::value.

Here is the call graph for this function:

◆ sort_by_col()

void Slic3r::GUI::ObjectGridTable::sort_by_col ( int col )

{
    //handle the sort logic
    if (col == col_name) {
        if (m_sort_col == col) {
            auto sort_func = [](ObjectGridRow* row1, ObjectGridRow* row2) {
                return (row2->name.value.compare(row1->name.value) < 0);
            };
            //sort_by_name();
            sort_row_data(sort_func);
            m_sort_col = -1;
        }
        else {
            auto sort_func = [](ObjectGridRow* row1, ObjectGridRow* row2) {
                return (row1->name.value.compare(row2->name.value) < 0);
            };
            //sort_by_name();
            sort_row_data(sort_func);
            m_sort_col = col;
        }
    }
    else if (col == col_filaments) {
    if (m_sort_col == col) {
      auto sort_func = [](ObjectGridRow* row1, ObjectGridRow* row2) {
        return (std::to_string(row2->filaments.value).compare(std::to_string(row1->filaments.value)) < 0);
      };
      sort_row_data(sort_func);
      m_sort_col = -1;
    }
    else {
      auto sort_func = [](ObjectGridRow* row1, ObjectGridRow* row2) {
        return (std::to_string(row1->filaments.value).compare(std::to_string(row2->filaments.value)) < 0);
      };
      sort_row_data(sort_func);
      m_sort_col = col;
    }
    }
    //else if (col == col_assemble_name) {
    //    if (m_sort_col == col) {
    //        compare_row_func sort_func = [](ObjectGridRow* row1, ObjectGridRow* row2) {
    //            //wxString string1 = GUI::from_u8(row1->assemble_name.value);
    //            //wxString string2 = GUI::from_u8(row2->assemble_name.value);
    //            //return (string1.compare(string2) <= 0);
    //            return (row2->assemble_name.value.compare(row1->assemble_name.value) < 0);
    //        };
    //        sort_row_data(sort_func);
    //        m_sort_col = -1;
    //    }
    //    else {
    //        compare_row_func sort_func = [](ObjectGridRow* row1, ObjectGridRow* row2) {
    //            //wxString string1 = GUI::from_u8(row1->assemble_name.value);
    //            //wxString string2 = GUI::from_u8(row2->assemble_name.value);
    //            //return (string1.compare(string2) <= 0);
    //            return (row1->assemble_name.value.compare(row2->assemble_name.value) < 0);
    //        };
    //        sort_row_data(sort_func);
    //        m_sort_col = col;
    //    }
    //}
    else if (col == col_plate_index) {
        if (m_sort_col == col) {
            compare_row_func sort_func = [](ObjectGridRow* row1, ObjectGridRow* row2) {
                int plate_1, plate_2;
                std::string row1_plate = row1->plate_index.value;
                std::string row2_plate = row2->plate_index.value;
                bool result = false;
 
                if (row1_plate == ObjectGridTable::plate_outside)
                    plate_1 = 100;
                else
                    plate_1 = std::atoi(row1_plate.c_str());
                if (row2_plate == ObjectGridTable::plate_outside)
                    plate_2 = 100;
                else
                    plate_2 = std::atoi(row2_plate.c_str());
 
                if (plate_2 < plate_1)
                    result = true;
                else if (plate_1 == plate_2) {
                    std::string row1_name = row1->name.value;
                    std::string row2_name = row2->name.value;
                    result = (row2_name < row1_name);
                }
                return result;
            };
            sort_row_data(sort_func);
            m_sort_col = -1;
        }
        else {
            compare_row_func sort_func = [](ObjectGridRow* row1, ObjectGridRow* row2) {
                int plate_1, plate_2;
                std::string row1_plate = row1->plate_index.value;
                std::string row2_plate = row2->plate_index.value;
                bool result = false;
 
                if (row1_plate == ObjectGridTable::plate_outside)
                    plate_1 = 100;
                else
                    plate_1 = std::atoi(row1_plate.c_str());
                if (row2_plate == ObjectGridTable::plate_outside)
                    plate_2 = 100;
                else
                    plate_2 = std::atoi(row2_plate.c_str());
 
                if (plate_1 < plate_2)
                    result = true;
                else if (plate_1 == plate_2) {
                    std::string row1_name = row1->name.value;
                    std::string row2_name = row2->name.value;
                    result = (row1_name < row2_name);
                }
                return result;
            };
            sort_row_data(sort_func);
            m_sort_col = col;
        }
    }
 
    return;
}

References col_filaments, col_name, col_plate_index, Slic3r::GUI::ObjectGridTable::ObjectGridRow::filaments, m_sort_col, Slic3r::GUI::ObjectGridTable::ObjectGridRow::name, Slic3r::GUI::ObjectGridTable::ObjectGridRow::plate_index, plate_outside, sort_row_data(), and Slic3r::ConfigOptionSingle< T >::value.

Referenced by OnCellLeftClick(), and Slic3r::GUI::ObjectGrid::OnColHeadLeftClick().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sort_by_default()

void Slic3r::GUI::ObjectGridTable::sort_by_default ( )

{
    compare_row_func sort_func = [](ObjectGridRow* row1, ObjectGridRow* row2) {
        int plate_1, plate_2;
        std::string row1_plate = row1->plate_index.value;
        std::string row2_plate = row2->plate_index.value;
        bool result = false;
 
        if (row1_plate == ObjectGridTable::plate_outside)
            plate_1 = 100;
        else
            plate_1 = std::atoi(row1_plate.c_str());
        if (row2_plate == ObjectGridTable::plate_outside)
            plate_2 = 100;
        else
            plate_2 = std::atoi(row2_plate.c_str());
 
        if (plate_1 < plate_2)
            result = true;
        else if (row1_plate == row2_plate) {
            std::string row1_name = row1->name.value;
            std::string row2_name = row2->name.value;
            result = (row1_name < row2_name);
        }
        return result;
    };
    sort_row_data(sort_func);
    m_sort_col = 0;
}

References m_sort_col, Slic3r::GUI::ObjectGridTable::ObjectGridRow::name, Slic3r::GUI::ObjectGridTable::ObjectGridRow::plate_index, plate_outside, sort_row_data(), and Slic3r::ConfigOptionSingle< T >::value.

Here is the call graph for this function:

◆ sort_row_data()

void Slic3r::GUI::ObjectGridTable::sort_row_data ( compare_row_func sort_func )

private

{
    int size = m_grid_data.size();
    if (!size)
        return;
 
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(" enter, this %1%, row_data size %2%") %this % m_grid_data.size();
    std::list<ObjectGridRow*> new_grid_rows;
    for ( auto it = m_grid_data.begin(); it != m_grid_data.end(); it++ )
    {
        if ((*it)->row_type == row_object)
           new_grid_rows.push_back(*it);
    }
    new_grid_rows.sort(sort_func);
    //std::sort(new_grid_rows.begin(), new_grid_rows.end(), sort_func);
    auto it = new_grid_rows.begin();
    while( it != new_grid_rows.end() )
    {
        if ((*it)->row_type != row_object) {
            ++it;
            continue;
        }
        auto origin_it = find(m_grid_data.begin(), m_grid_data.end(), *it);
        //move it to next for insert
        ++it;
        if (origin_it == m_grid_data.end()) //should not happen, finished
            break;
        ++origin_it;
        while (origin_it != m_grid_data.end() && ((*origin_it)->row_type != row_object))
        {
            new_grid_rows.insert(it, *origin_it);
            ++origin_it;
        }
    }
    m_grid_data.clear();
    m_grid_data.resize(size);
    std::copy(new_grid_rows.begin(), new_grid_rows.end(), m_grid_data.begin());
    new_grid_rows.clear();
 
    //update_row_properties();
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(" finished, this %1%, row_data size %2%") %this % m_grid_data.size();
}

References m_grid_data, and row_object.

Referenced by sort_by_col(), and sort_by_default().

Here is the caller graph for this function:

◆ update_filament_to_config()

void Slic3r::GUI::ObjectGridTable::update_filament_to_config	(	ModelConfig *	config,
		std::string &	key,
		ConfigOption &	new_value,
		ConfigOption &	ori_value,
		bool	is_object )

{
    if (!is_object)
        update_value_to_config(config, key, new_value, ori_value);
    else {
        //always create extruder in object config
        config->set_key_value(key, new_value.clone());
        config->touch();
    }
}

References Slic3r::ConfigOption::clone(), Slic3r::ModelConfig::set_key_value(), Slic3r::ModelConfig::touch(), and update_value_to_config().

Referenced by OnCellLeftClick(), and SetValue().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_row_properties()

void Slic3r::GUI::ObjectGridTable::update_row_properties ( )

private

{
    ObjectGrid* grid_table = m_panel->m_object_grid;
    //col 0 no need to update, always uneditable
    for (int col = 1; col < col_speed_perimeter_reset; col++)
    {
        ObjectGridTable::ObjectGridCol* grid_col = get_grid_col(col);
        //grid_table->SetColSize(col, grid_col->size);
 
        //row 0 no need to update, always for headers
        for (int row = 1; row < get_row_count(); row++)
        {
            ObjectGridTable::ObjectGridRow* grid_row = get_grid_row(row-1);
 
            if ((!grid_col->b_icon) && (grid_col->b_for_object)) {
                if (grid_row->row_type == ObjectGridTable::row_volume) {
                    grid_table->SetReadOnly(row, col);
                    //FIXME: recycle the old editor and renders
                    grid_table->SetCellEditor(row, col, new wxGridCellAutoWrapStringEditor());
                    grid_table->SetCellRenderer(row, col, new wxGridCellAutoWrapStringRenderer());
                }
                else {
                    grid_table->SetReadOnly(row, col, false);
 
                    switch (grid_col->type)
                    {
                        case coString:
                            if (col == ObjectGridTable::col_plate_index)
                                grid_table->SetReadOnly(row, col);
                            grid_table->SetCellEditor(row, col, new GridCellTextEditor());
                            //grid_table->SetCellRenderer(row, col, new wxGridCellAutoWrapStringRenderer());
                            grid_table->SetCellFitMode(row, col, wxGridFitMode::Ellipsize());
                            break;
                        case coBool:
                            grid_table->SetCellEditor(row, col, new GridCellSupportEditor());
                            //grid_table->SetCellEditor(row, col, new wxGridCellBoolEditor());
                            //grid_table->SetCellRenderer(row, col, new GridCellSupportRenderer());
                            grid_table->SetCellRenderer(row, col, new GridCellSupportRenderer());
                            break;
                        case coInt:
                            grid_table->SetCellEditor(row, col, new GridCellTextEditor());
                            grid_table->SetCellRenderer(row, col, new  wxGridCellNumberRenderer());
                            break;
                        case coEnum:
                            if (col == ObjectGridTable::col_filaments) {
                                GridCellFilamentsEditor *filament_editor = new GridCellFilamentsEditor(grid_col->choices, false, &m_panel->m_color_bitmaps);
                                grid_table->SetCellEditor(row, col, filament_editor);
                                grid_table->SetCellRenderer(row, col, new GridCellFilamentsRenderer());
                            } else {
                                GridCellChoiceEditor *combo_editor = new GridCellChoiceEditor(grid_col->choices);
                                grid_table->SetCellEditor(row, col, combo_editor);
                                grid_table->SetCellRenderer(row, col, new wxGridCellChoiceRenderer());
                                //new wxGridCellChoiceEditor(grid_col->choice_count, grid_col->choices));
                            }  
                            break;
                        case coFloat: {
              grid_table->SetCellEditor(row, col, new GridCellTextEditor());
                            if (col == ObjectGridTable::col_speed_perimeter) {
                                grid_table->SetCellRenderer(row, col, new wxGridCellFloatRenderer(6, 0));
                            }
                            else {
                                grid_table->SetCellRenderer(row, col, new wxGridCellFloatRenderer(6, 2));
                            }
              
              break;
                        }
                        case coPercent:
                        {
                            grid_table->SetCellEditor(row, col, new GridCellTextEditor());
                            grid_table->SetCellRenderer(row, col, new wxGridCellFloatRenderer(6,1));
                            break;
                        }
                        default:
                            break;
                    }
                }
            }
            else if (col == ObjectGridTable::col_name) {
                grid_table->SetCellFont(row, col, Label::Body_12);
                /*if (grid_row->row_type == ObjectGridTable::row_object)
                    grid_table->SetCellFont(row, col, Label::Head_14);
                else
                    grid_table->SetCellFont(row, col, Label::Body_14);*/
            }
        }
    }
 
    return;
}

References Slic3r::GUI::ObjectGridTable::ObjectGridCol::b_for_object, Slic3r::GUI::ObjectGridTable::ObjectGridCol::b_icon, Label::Body_12, Slic3r::GUI::ObjectGridTable::ObjectGridCol::choices, Slic3r::coBool, Slic3r::coEnum, Slic3r::coFloat, Slic3r::coInt, col_filaments, col_name, col_plate_index, col_speed_perimeter, col_speed_perimeter_reset, Slic3r::coPercent, Slic3r::coString, get_grid_col(), get_grid_row(), get_row_count(), m_panel, Slic3r::GUI::ObjectGridTable::ObjectGridRow::row_type, row_volume, and Slic3r::GUI::ObjectGridTable::ObjectGridCol::type.

Here is the call graph for this function:

◆ update_value_to_config()

void Slic3r::GUI::ObjectGridTable::update_value_to_config	(	ModelConfig *	config,
		std::string &	key,
		ConfigOption &	new_value,
		ConfigOption &	ori_value )

{
    if (!config->has(key))
    {
        if (ori_value != new_value)
            config->set_key_value(key, new_value.clone());
    }
    else {
        if (ori_value != new_value)
            config->set_key_value(key, new_value.clone());
        else
            config->erase(key);
    }
    config->touch();
}

References Slic3r::ConfigOption::clone(), Slic3r::ModelConfig::erase(), Slic3r::ModelConfig::has(), Slic3r::ModelConfig::set_key_value(), and Slic3r::ModelConfig::touch().

Referenced by OnCellLeftClick(), SetValue(), SetValueAsBool(), SetValueAsDouble(), SetValueAsLong(), and update_filament_to_config().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_value_to_object()

void Slic3r::GUI::ObjectGridTable::update_value_to_object	(	Model *	model,
		ObjectGridRow *	grid_row,
		int	col )

{
    ModelObject* object = model->objects[grid_row->object_id];
    ModelVolume* volume = nullptr;
    std::string* name_ptr = nullptr;
    std::string name_value;
 
    if (!object) {
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(", object_id %1%, volume_id %2%, can not find modelObject anymore!")%grid_row->object_id %grid_row->volume_id;
        return;
    }
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(", object_id %1%, volume_id %2%, col %3%, row_type %4%")%grid_row->object_id %grid_row->volume_id %col %grid_row->row_type;
 
    if (grid_row->row_type != row_object) {
        volume = object->volumes[grid_row->volume_id];
        if (col == col_name) {
            name_ptr = &(volume->name);
            name_value = grid_row->name.value;
        }
    }
    else {
        if (col == col_name) {
            name_ptr = &(object->name);
            name_value = grid_row->name.value;
        }
       /* else if (col == col_assemble_name) {
            name_ptr = &(object->module_name);
            name_value = grid_row->assemble_name.value;
        }*/
        else if (col == col_printable) {
            object->printable = grid_row->printable.value;
            object->instances[0]->printable = object->printable;
 
            wxGetApp().obj_list()->printable_state_changed({object});
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(", change object %1%'s printable to %2%")%object->module_name %object->printable;
        }
    }
 
    if ((name_ptr) && (*name_ptr != name_value)) {
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(", change name from %1% to %2%!")%name_ptr->c_str() %name_value.c_str();
        *name_ptr = name_value;
        //notify object list
        wxGetApp().obj_list()->update_name_for_items();
    }
}

References col_name, col_printable, Slic3r::GUI::ObjectGridTable::ObjectGridRow::name, Slic3r::ModelVolume::name, Slic3r::GUI::ObjectGridTable::ObjectGridRow::object_id, Slic3r::Model::objects, Slic3r::GUI::ObjectGridTable::ObjectGridRow::printable, row_object, Slic3r::GUI::ObjectGridTable::ObjectGridRow::row_type, Slic3r::ConfigOptionSingle< T >::value, and Slic3r::GUI::ObjectGridTable::ObjectGridRow::volume_id.

Referenced by OnCellLeftClick(), SetValue(), and SetValueAsBool().

Here is the caller graph for this function:

◆ update_volume_values_from_object()

void Slic3r::GUI::ObjectGridTable::update_volume_values_from_object	(	int	row,
		int	col )

{
    ObjectGridRow* grid_row = m_grid_data[row - 1];
    bool need_refresh = false;
    DynamicPrintConfig&  global_config   = wxGetApp().preset_bundle->prints.get_edited_preset().config;
    if (grid_row->row_type == row_object) {
        int next_row = row + 1;
        while ((next_row - 1) < m_grid_data.size())
        {
            ObjectGridRow* part_row = m_grid_data[next_row - 1];
            if (part_row->row_type == row_volume) {
                if (col == col_filaments) {
                    auto extruder_id_ptr = static_cast<const ConfigOptionInt*>(part_row->config->option(m_col_data[col]->key));
                    if (extruder_id_ptr) {
                        part_row->filaments = *extruder_id_ptr;
                        if (part_row->filaments == grid_row->filaments) {
                            part_row->config->erase(m_col_data[col_filaments]->key);
                        }
                    }
                    else
                        part_row->filaments = grid_row->filaments;
                    //part_row->ori_filaments = grid_row->filaments;
                }
                else
                    reload_part_data(part_row, grid_row, m_col_data[col]->category, global_config);
                next_row++;
                need_refresh = true;
            }
            else
                break;
        }
    }
 
    if (need_refresh)
        m_panel->m_object_grid->ForceRefresh();
 
    return;
}

References col_filaments, Slic3r::GUI::ObjectGridTable::ObjectGridRow::config, Slic3r::ModelConfig::erase(), Slic3r::GUI::ObjectGridTable::ObjectGridRow::filaments, m_col_data, m_grid_data, m_panel, Slic3r::ModelConfig::option(), reload_part_data(), row_object, Slic3r::GUI::ObjectGridTable::ObjectGridRow::row_type, and row_volume.

Referenced by OnCellLeftClick(), and SetValue().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ category_all

std::string Slic3r::GUI::ObjectGridTable::category_all = "All"

static

Referenced by init_cols(), reload_object_data(), reload_part_data(), Slic3r::GUI::ObjectTableSettings::resetAllValues(), Slic3r::GUI::ObjectTableSettings::update_config_values(), and Slic3r::GUI::ObjectTableSettings::ValueChanged().

◆ m_col_data

std::vector<ObjectGridCol*> Slic3r::GUI::ObjectGridTable::m_col_data

private

◆ m_colLabels

wxArrayString Slic3r::GUI::ObjectGridTable::m_colLabels

private

Referenced by GetColLabelValue(), and SetColLabelValue().

◆ m_current_col

int Slic3r::GUI::ObjectGridTable::m_current_col {-1}

private

555{-1};

Referenced by OnSelectCell(), and resetValuesInCurrentCell().

◆ m_current_row

int Slic3r::GUI::ObjectGridTable::m_current_row {-1}

private

554{-1};

Referenced by OnSelectCell(), and resetValuesInCurrentCell().

◆ m_data_valid

bool Slic3r::GUI::ObjectGridTable::m_data_valid {false}

private

543{false};

Referenced by construct_object_configs(), GetValue(), GetValueAsBool(), GetValueAsDouble(), GetValueAsLong(), and release_object_configs().

◆ m_grid_data

std::vector<ObjectGridRow*> Slic3r::GUI::ObjectGridTable::m_grid_data

private

◆ m_icon_col_width

int Slic3r::GUI::ObjectGridTable::m_icon_col_width { 0 }

536{ 0 };

Referenced by Slic3r::GUI::GridCellIconRenderer::Draw().

◆ m_icon_row_height

int Slic3r::GUI::ObjectGridTable::m_icon_row_height { 0 }

537{ 0 };

Referenced by Slic3r::GUI::GridCellIconRenderer::Draw().

◆ m_panel

ObjectTablePanel* Slic3r::GUI::ObjectGridTable::m_panel { nullptr }

538{ nullptr };

Referenced by ObjectGridTable(), construct_object_configs(), get_color_bitmap(), get_undo_bitmap(), init_cols(), OnCellLeftClick(), OnCellValueChanged(), OnSelectCell(), reload_cell_data(), resetValuesInCurrentCell(), SetSelection(), SetValue(), SetValueAsBool(), update_row_properties(), and update_volume_values_from_object().

◆ m_selected_cells

std::list<wxGridCellCoords> Slic3r::GUI::ObjectGridTable::m_selected_cells

private

Referenced by ~ObjectGridTable(), and OnSelectCell().

◆ m_sort_col

int Slic3r::GUI::ObjectGridTable::m_sort_col { -1 }

private

547{ -1 };

Referenced by sort_by_col(), and sort_by_default().

◆ plate_outside

std::string Slic3r::GUI::ObjectGridTable::plate_outside = L("Outside")

static

Referenced by construct_object_configs(), sort_by_col(), and sort_by_default().

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

/home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/GUI_ObjectTable.hpp
/home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/GUI_ObjectTable.cpp

	OrcaSlicer latest OrcaSlicer

Classes

Public Types

Public Member Functions

Public Attributes

Static Public Attributes

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ compare_row_func

Member Enumeration Documentation

◆ GridColType

◆ GridRowType

Constructor & Destructor Documentation

◆ ObjectGridTable()

◆ ~ObjectGridTable()

Member Function Documentation

◆ CanGetValueAs()

◆ CanSetValueAs()

◆ construct_object_configs()

◆ convert_filament_string()

◆ enable_reset_all_button()

◆ get_col_count()

◆ get_color_bitmap()

◆ get_grid_col()

◆ get_grid_row()

◆ get_object_config_value()

◆ get_row_count()

◆ get_undo_bitmap()

◆ get_volume_config_value()

◆ GetColLabelValue()

◆ GetNumberCols()

◆ GetNumberRows()

◆ GetTypeName()

◆ GetValue()

◆ GetValueAsBool()

◆ GetValueAsDouble()

◆ GetValueAsLong()

◆ init_cols()

◆ IsEmptyCell()

◆ OnCellLeftClick()

◆ OnCellValueChanged()

◆ OnRangeSelected()

◆ OnSelectCell()

◆ release_object_configs()

◆ reload_cell_data()

◆ reload_object_data()

◆ reload_part_data()

◆ resetValuesInCurrentCell()

◆ SetColLabelValue()

◆ SetSelection()

◆ SetValue()

◆ SetValueAsBool()

◆ SetValueAsDouble()

◆ SetValueAsLong()

◆ sort_by_col()

◆ sort_by_default()

◆ sort_row_data()

◆ update_filament_to_config()

◆ update_row_properties()

◆ update_value_to_config()

◆ update_value_to_object()

◆ update_volume_values_from_object()

Member Data Documentation

◆ category_all

◆ m_col_data

◆ m_colLabels

◆ m_current_col

◆ m_current_row

◆ m_data_valid

◆ m_grid_data

◆ m_icon_col_width

◆ m_icon_row_height

◆ m_panel

◆ m_selected_cells

◆ m_sort_col

◆ plate_outside