Slic3r::GUI::GizmoObjectManipulation Class Reference

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

Collaboration diagram for Slic3r::GUI::GizmoObjectManipulation:

Classes
struct	Cache

Public Types
enum class	RotateType { None , Relative , Absolute }

Public Member Functions
	GizmoObjectManipulation (GLCanvas3D &glcanvas)
	~GizmoObjectManipulation ()
bool	IsShown ()
void	UpdateAndShow (const bool show)
void	update_ui_from_settings ()
void	set_dirty ()
void	update_if_dirty ()
void	set_uniform_scaling (const bool uniform_scale)
bool	get_uniform_scaling () const
void	set_use_object_cs (bool flag)
bool	get_use_object_cs ()
void	set_coordinates_type (ECoordinatesType type)
ECoordinatesType	get_coordinates_type () const
bool	is_world_coordinates () const
bool	is_instance_coordinates () const
bool	is_local_coordinates () const
const Cache &	get_cache ()
void	reset_cache ()
void	limit_scaling_ratio (Vec3d &scaling_factor) const
void	on_change (const std::string &opt_key, int axis, double new_value)
bool	render_combo (ImGuiWrapper *imgui_wrapper, const std::string &label, const std::vector< std::string > &lines, size_t &selection_idx, float label_width, float item_width)
void	do_render_move_window (ImGuiWrapper *imgui_wrapper, std::string window_name, float x, float y, float bottom_limit)
void	do_render_rotate_window (ImGuiWrapper *imgui_wrapper, std::string window_name, float x, float y, float bottom_limit)
void	do_render_scale_input_window (ImGuiWrapper *imgui_wrapper, std::string window_name, float x, float y, float bottom_limit)
float	max_unit_size (int number, Vec3d &vec1, Vec3d &vec2, std::string str)
bool	reset_button (ImGuiWrapper *imgui_wrapper, bool enabled)
bool	reset_zero_button (ImGuiWrapper *imgui_wrapper, bool enabled)
bool	bbl_checkbox (const wxString &label, bool &value)
void	set_init_rotation (const Geometry::Transformation &value)
const GLGizmoAlignment &	get_alignment_helper () const
GLGizmoAlignment::AlignType	get_hovered_align_type () const
bool	get_align_to_parent () const
void	reset_align_state ()

Public Attributes
Cache	m_cache
bool	m_imperial_units { false }
bool	m_use_object_cs {false}
bool	m_dirty = false
std::string	m_new_title_string
std::string	m_new_move_label_string
std::string	m_new_rotate_label_string
std::string	m_new_scale_label_string
std::string	m_new_unit_string
Vec3d	m_new_position
Vec3d	m_new_rotation
Vec3d	m_new_absolute_rotation
Vec3d	m_new_scale
Vec3d	m_new_size
Vec3d	m_unscale_size
Vec3d	m_buffered_position
Vec3d	m_buffered_rotation
Vec3d	m_buffered_absolute_rotation
Vec3d	m_buffered_scale
Vec3d	m_buffered_size
Vec3d	cs_center
bool	m_new_enabled {true}
bool	m_uniform_scale {true}
ECoordinatesType	m_coordinates_type {ECoordinatesType::World}
bool	m_show_reset_0_rotation {false}
bool	m_show_clear_rotation { false }
bool	m_show_clear_scale { false }
bool	m_enable_drop_to_bed { false }
RotateType	m_last_rotate_type {RotateType::None}

Static Public Attributes
static const double	in_to_mm = 25.4
static const double	mm_to_in = 0.0393700787
static const double	g_to_oz = 0.035274
static const double	oz_to_g = 28.34952

Protected Attributes
float	last_move_input_window_width = 0.0f
float	last_rotate_input_window_width = 0.0f
float	last_scale_input_window_width = 0.0f

Private Member Functions
void	reset_settings_value ()
void	update_settings_value (const Selection &selection)
void	update_buffered_value ()
void	update_reset_buttons_visibility ()
void	change_position_value (int axis, double value)
void	change_rotation_value (int axis, double value)
void	change_absolute_rotation_value (int axis, double value)
void	change_scale_value (int axis, double value)
void	change_size_value (int axis, double value)
void	do_scale (int axis, const Vec3d &scale) const
void	reset_position_value ()
void	reset_rotation_value (bool reset_relative)
void	reset_scale_value ()

Private Attributes
GLCanvas3D &	m_glcanvas
unsigned int	m_last_active_item { 0 }
GLGizmoAlignment	m_alignment_helper
GLGizmoAlignment::AlignType	m_hovered_align_type {GLGizmoAlignment::AlignType::NONE}
bool	m_align_to_parent {false}
bool	m_can_align_within {false}
std::vector< std::pair< wxString, wxString > >	m_shortcuts_move
std::vector< std::pair< wxString, wxString > >	m_shortcuts_rotate
std::vector< std::pair< wxString, wxString > >	m_shortcuts_scale
Vec3d	m_init_rotation
Transform3d	m_init_rotation_scale_tran

Detailed Description

Member Enumeration Documentation

RotateType

enum class Slic3r::GUI::GizmoObjectManipulation::RotateType

strong

Enumerator
None
Relative
Absolute

                          { None, Relative, Absolute
    };

Constructor & Destructor Documentation

GizmoObjectManipulation()

Slic3r::GUI::GizmoObjectManipulation::GizmoObjectManipulation

(

GLCanvas3D &

glcanvas

)

    : m_glcanvas(glcanvas), m_alignment_helper(glcanvas)
{
    m_imperial_units = wxGetApp().app_config->get("use_inches") == "1";
    m_new_unit_string = m_imperial_units ? L_CONTEXT("in", "inches") : L("mm");
 
    const wxString shift                   = GUI::shortkey_shift_prefix();
    const wxString alt                     = GUI::shortkey_alt_prefix();
    const wxString ctrl                    = GUI::shortkey_ctrl_prefix();
 
    m_shortcuts_move = {
        {alt + _L("Left mouse button"),     _L("Part selection")},
        {ctrl + _L("Left mouse button"),    _L("Select multiple objects")},
        {shift + _L("Left mouse button"),   _L("Fixed step drag")},
        {_L("Context Menu"),                _L("Toggle Auto-Drop")}
    };
 
    m_shortcuts_rotate = {
        {alt + _L("Left mouse button"),     _L("Part selection")},
        {_L("Context Menu"),                _L("Toggle Auto-Drop")}
    };
 
    m_shortcuts_scale = {
        {alt + _L("Left mouse button"),     _L("Part selection")},
        {shift + _L("Left mouse button"),   _L("Fixed step drag")},
        {ctrl + _L("Left mouse button"),    _L("Single sided scaling")},
        {_L("Context Menu"),                _L("Toggle Auto-Drop")}
    };
}

References _L, L, L_CONTEXT, m_alignment_helper, m_glcanvas, m_imperial_units, m_new_unit_string, m_shortcuts_move, m_shortcuts_rotate, m_shortcuts_scale, Slic3r::GUI::shortkey_alt_prefix(), Slic3r::GUI::shortkey_ctrl_prefix(), and Slic3r::GUI::shortkey_shift_prefix().

Here is the call graph for this function:

~GizmoObjectManipulation()

Slic3r::GUI::GizmoObjectManipulation::~GizmoObjectManipulation ( )

inline

{}

Member Function Documentation

bbl_checkbox()

bool Slic3r::GUI::GizmoObjectManipulation::bbl_checkbox	(	const wxString &	label,
		bool &	value )

{
     bool result;
     bool b_value = value;
     if (b_value) {
         ImGui::PushStyleColor(ImGuiCol_FrameBg, ImVec4(0.00f, 0.68f, 0.26f, 1.00f));
         ImGui::PushStyleColor(ImGuiCol_FrameBgHovered, ImVec4(0.00f, 0.68f, 0.26f, 1.00f));
         ImGui::PushStyleColor(ImGuiCol_FrameBgActive, ImVec4(0.00f, 0.68f, 0.26f, 1.00f));
     }
     auto label_utf8 = into_u8(label);
     result          = ImGui::BBLCheckbox(label_utf8.c_str(), &value);
 
     if (b_value) { ImGui::PopStyleColor(3); }
     return result;
}

References Slic3r::GUI::into_u8().

Here is the call graph for this function:

change_absolute_rotation_value()

void Slic3r::GUI::GizmoObjectManipulation::change_absolute_rotation_value ( int axis, double value )

private

                                                                                   {
    if (std::abs(m_cache.absolute_rotation_rounded(axis) - value) < EPSILON)
        return;
 
    Vec3d absolute_rotation = m_cache.absolute_rotation;
    absolute_rotation(axis) = value;
 
    Selection &selection = m_glcanvas.get_selection();
    TransformationType transformation_type;
    transformation_type.set_relative();
    if (selection.is_single_full_instance())
        transformation_type.set_independent();
    if (is_local_coordinates())
        transformation_type.set_local();
    if (is_instance_coordinates())
        transformation_type.set_instance();
 
    selection.setup_cache();
    auto diff_rotation = transformation_type.absolute() ? absolute_rotation : absolute_rotation - m_cache.absolute_rotation;
    selection.rotate((M_PI / 180.0) * diff_rotation, transformation_type);
    wxGetApp().plater()->take_snapshot("set absolute orientation", UndoRedo::SnapshotType::GizmoAction);
    m_glcanvas.do_rotate("");
 
    m_cache.absolute_rotation               = absolute_rotation;
    m_cache.absolute_rotation_rounded(axis) = DBL_MAX;
    this->UpdateAndShow(true);
}

References Slic3r::GUI::TransformationType::absolute(), EPSILON, Slic3r::UndoRedo::GizmoAction, is_instance_coordinates(), is_local_coordinates(), Slic3r::GUI::Selection::is_single_full_instance(), m_cache, m_glcanvas, M_PI, Slic3r::GUI::Selection::rotate(), Slic3r::GUI::TransformationType::set_independent(), Slic3r::GUI::TransformationType::set_instance(), Slic3r::GUI::TransformationType::set_local(), Slic3r::GUI::TransformationType::set_relative(), Slic3r::GUI::Selection::setup_cache(), and UpdateAndShow().

Referenced by on_change().

Here is the call graph for this function:

Here is the caller graph for this function:

change_position_value()

void Slic3r::GUI::GizmoObjectManipulation::change_position_value ( int axis, double value )

private

{
    if (std::abs(m_cache.position_rounded(axis) - value) < EPSILON)
        return;
 
    Vec3d position = m_cache.position;
    position(axis) = value;
 
    Selection& selection = m_glcanvas.get_selection();
    selection.setup_cache();
    TransformationType trafo_type;
    trafo_type.set_relative();
    switch (m_coordinates_type) {
    case ECoordinatesType::Instance: {
        trafo_type.set_instance();
        break;
    }
    case ECoordinatesType::Local: {
        trafo_type.set_local();
        break;
    }
    default: {
        break;
    }
    }
    selection.translate(position - m_cache.position, trafo_type);
    wxGetApp().plater()->take_snapshot("Set Position", UndoRedo::SnapshotType::GizmoAction);
    m_glcanvas.do_move("");
 
    m_cache.position = position;
  m_cache.position_rounded(axis) = DBL_MAX;
    this->UpdateAndShow(true);
}

References EPSILON, Slic3r::UndoRedo::GizmoAction, Slic3r::GUI::Instance, Slic3r::GUI::Local, m_cache, m_coordinates_type, m_glcanvas, Slic3r::GUI::TransformationType::set_instance(), Slic3r::GUI::TransformationType::set_local(), Slic3r::GUI::TransformationType::set_relative(), Slic3r::GUI::Selection::setup_cache(), Slic3r::GUI::Selection::translate(), and UpdateAndShow().

Referenced by on_change().

Here is the call graph for this function:

Here is the caller graph for this function:

change_rotation_value()

void Slic3r::GUI::GizmoObjectManipulation::change_rotation_value ( int axis, double value )

private

{
    if (std::abs(m_cache.rotation_rounded(axis) - value) < EPSILON)
        return;
 
    Vec3d rotation = m_cache.rotation;
    rotation(axis) = value;
 
    Selection& selection = m_glcanvas.get_selection();
 
    TransformationType transformation_type;
    transformation_type.set_relative();
    if (selection.is_single_full_instance())
        transformation_type.set_independent();
    if (is_local_coordinates())
        transformation_type.set_local();
    if (is_instance_coordinates())
        transformation_type.set_instance();
 
    selection.setup_cache();
    selection.rotate((M_PI / 180.0) * (transformation_type.absolute() ? rotation : rotation - m_cache.rotation), transformation_type);
    wxGetApp().plater()->take_snapshot(_u8L("Set orientation"), UndoRedo::SnapshotType::GizmoAction);
    m_glcanvas.do_rotate("");
 
    m_cache.rotation = rotation;
  m_cache.rotation_rounded(axis) = DBL_MAX;
    this->UpdateAndShow(true);
}

References _u8L, Slic3r::GUI::TransformationType::absolute(), EPSILON, Slic3r::UndoRedo::GizmoAction, is_instance_coordinates(), is_local_coordinates(), Slic3r::GUI::Selection::is_single_full_instance(), m_cache, m_glcanvas, M_PI, Slic3r::GUI::Selection::rotate(), Slic3r::GUI::TransformationType::set_independent(), Slic3r::GUI::TransformationType::set_instance(), Slic3r::GUI::TransformationType::set_local(), Slic3r::GUI::TransformationType::set_relative(), Slic3r::GUI::Selection::setup_cache(), and UpdateAndShow().

Referenced by on_change().

Here is the call graph for this function:

Here is the caller graph for this function:

change_scale_value()

void Slic3r::GUI::GizmoObjectManipulation::change_scale_value ( int axis, double value )

private

{
    if (value <= 0.0)
        return;
    if (std::abs(m_cache.scale_rounded(axis) - value) < EPSILON) {
        m_show_clear_scale = (m_cache.scale / 100.0f - Vec3d::Ones()).norm() > 0.001;
        return;
    }
    Vec3d scale     = m_cache.scale;
    scale(axis)     = value;
    Vec3d ref_scale = m_cache.scale;
    const Selection &selection = m_glcanvas.get_selection();
    if (selection.is_single_volume_or_modifier()) {
        scale     = scale.cwiseQuotient(ref_scale); // scale / ref_scale
        ref_scale =  Vec3d::Ones();
    } else if (selection.is_single_full_instance())
        ref_scale = 100 * Vec3d::Ones();
    this->do_scale(axis, scale.cwiseQuotient(ref_scale));
 
    m_cache.scale = scale;
  m_cache.scale_rounded(axis) = DBL_MAX;
  this->UpdateAndShow(true);
}

References do_scale(), EPSILON, Slic3r::GUI::Selection::is_single_full_instance(), Slic3r::GUI::Selection::is_single_volume_or_modifier(), m_cache, m_glcanvas, m_show_clear_scale, scale(), and UpdateAndShow().

Referenced by on_change(), and reset_scale_value().

Here is the call graph for this function:

Here is the caller graph for this function:

change_size_value()

void Slic3r::GUI::GizmoObjectManipulation::change_size_value ( int axis, double value )

private

{
    if (value <= 0.0)
        return;
    if (std::abs(m_cache.size_rounded(axis) - value) < EPSILON)
        return;
 
    Vec3d size = m_cache.size;
    size(axis) = value;
 
    const Selection& selection = m_glcanvas.get_selection();
 
    Vec3d ref_size = m_cache.size;
    if (selection.is_single_volume_or_modifier()) {
        size     = size.cwiseQuotient(ref_size);
        ref_size = Vec3d::Ones();
    } else if (selection.is_single_full_instance()) {
        if (is_world_coordinates())
            ref_size = selection.get_full_unscaled_instance_bounding_box().size();
        else
            ref_size = selection.get_full_unscaled_instance_local_bounding_box().size();
    }
 
    this->do_scale(axis, size.cwiseQuotient(ref_size));
 
    m_cache.size = size;
  m_cache.size_rounded(axis) = DBL_MAX;
  this->UpdateAndShow(true);
}

References do_scale(), EPSILON, Slic3r::GUI::Selection::get_full_unscaled_instance_bounding_box(), Slic3r::GUI::Selection::get_full_unscaled_instance_local_bounding_box(), Slic3r::GUI::Selection::is_single_full_instance(), Slic3r::GUI::Selection::is_single_volume_or_modifier(), is_world_coordinates(), m_cache, m_glcanvas, Slic3r::BoundingBox3Base< PointType >::size(), and UpdateAndShow().

Referenced by on_change().

Here is the call graph for this function:

Here is the caller graph for this function:

do_render_move_window()

void Slic3r::GUI::GizmoObjectManipulation::do_render_move_window	(	ImGuiWrapper *	imgui_wrapper,
		std::string	window_name,
		float	x,
		float	y,
		float	bottom_limit )

{
    float scale = m_glcanvas.get_scale();
#ifdef WIN32
    scale *= (float)get_dpi_for_window(wxGetApp().GetTopWindow()) / (float)DPI_DEFAULT;
#endif // WIN32
 
    // BBS: GUI refactor: move gizmo to the right
    if (abs(last_move_input_window_width) > 0.01f) {
        if (x + last_move_input_window_width > m_glcanvas.get_canvas_size().get_width()) {
            if (last_move_input_window_width > m_glcanvas.get_canvas_size().get_width())
                x = 0;
            else
                x = m_glcanvas.get_canvas_size().get_width() - last_move_input_window_width;
        }
    }
#if BBS_TOOLBAR_ON_TOP
    imgui_wrapper->set_next_window_pos(x, y, ImGuiCond_Always, 0.f, 0.0f);
#else
    imgui_wrapper->set_next_window_pos(x, y, ImGuiCond_Always, 1.0f, 0.0f);
#endif
 
    // BBS
    ImGuiWrapper::push_toolbar_style(m_glcanvas.get_scale());
    ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(0.0, 6.0));
 
    const ImGuiStyle &style         = ImGui::GetStyle();
 
    std::string name = this->m_new_title_string + "##" + window_name;
    imgui_wrapper->begin(_L(name), ImGuiWrapper::TOOLBAR_WINDOW_FLAGS);
 
    auto update = [this](unsigned int active_id, std::string opt_key, Vec3d original_value, Vec3d new_value) -> int {
        for (int i = 0; i < 3; i++) {
            if (original_value[i] != new_value[i]) {
                if (active_id != m_last_active_item) {
                    on_change(opt_key, i, new_value[i]);
                    return i;
                }
            }
        }
        return -1;
    };
 
    float space_size    = imgui_wrapper->get_style_scaling() * 8;
    // The align section shares the combo width, the caption column and the input columns of the position row.
    const bool show_align = m_glcanvas.get_canvas_type() == GLCanvas3D::ECanvasType::CanvasView3D &&
                            !m_glcanvas.get_selection().is_wipe_tower();
    //ORCA
    float coord_combo_width = std::max({
        imgui_wrapper->calc_text_size(_L("World")).x,
        imgui_wrapper->calc_text_size(_L("Object")).x,
        imgui_wrapper->calc_text_size(_L("Part")).x
    });
    float label_max = std::max({
        imgui_wrapper->calc_text_size(_L("Position")).x,
        imgui_wrapper->calc_text_size(_L("Relative")).x
    });
    if (show_align) {
        coord_combo_width = std::max({coord_combo_width, imgui_wrapper->calc_text_size(_L("Selection")).x,
                                      imgui_wrapper->calc_text_size(_L("Object")).x,
                                      imgui_wrapper->calc_text_size(_L("Plate")).x});
        label_max         = std::max(label_max, imgui_wrapper->calc_text_size(_L("Distribute")).x);
    }
    coord_combo_width += imgui_wrapper->calc_text_size("xxx"sv).x + imgui_wrapper->scaled(3.5f);
    float caption_max = std::max(label_max, coord_combo_width - 3 * space_size);
    float end_text_size = imgui_wrapper->calc_text_size(this->m_new_unit_string).x;
 
    // position
    Vec3d original_position;
    if (this->m_imperial_units)
        original_position = this->m_new_position * this->mm_to_in;
    else
        original_position = this->m_new_position;
    Vec3d display_position = m_buffered_position;
 
    // Rotation
    float unit_size = imgui_wrapper->calc_text_size(MAX_SIZE).x + space_size;
    // Four align buttons sit under each axis' input, a space before the next axis, so the inputs widen to hold them.
    const float align_icon_size   = 16.f * scale;
    const float align_button_size = align_icon_size + 2.f * style.FramePadding.x;  // ORCA
    if (show_align) {
        unit_size = std::max(unit_size, 3.f * align_button_size);
        unit_size = std::round(unit_size); // ORCA keep columns on whole pixels
    }
    int   index      = 1;
    int   index_unit = 1;
 
    ImGui::AlignTextToFramePadding();
    unsigned int current_active_id = ImGui::GetActiveID();
 
    Selection &              selection = m_glcanvas.get_selection();
    std::vector<std::string> modes     = {_u8L("World"), _u8L("Object")};//_u8L("Part") // ORCA use shorter terms to make UI more compact
    if (selection.is_multiple_full_object() || selection.is_wipe_tower()) {
        modes.pop_back();
    }
    size_t selection_idx = (int) m_coordinates_type;
    if (selection_idx >= modes.size()) {
        set_coordinates_type(ECoordinatesType::World);
        selection_idx = 0;
    }
 
    ImGuiWrapper::push_combo_style(m_glcanvas.get_scale());
    bool combox_changed = false;
    if (render_combo(imgui_wrapper, "", modes, selection_idx, 0, coord_combo_width)) {
        combox_changed = true;
    }
    ImGuiWrapper::pop_combo_style();
    // After pop_combo_style(): its light popup background would hide the tooltip's white text.
    if (ImGui::IsItemHovered()) {
        auto tooltip_str = _L("Coordinate system used for transform actions.");
        imgui_wrapper->tooltip(tooltip_str, imgui_wrapper->calc_text_size(tooltip_str).x + 3 * space_size);
    }
 
    // ORCA use TextColored to match axes color
    float offset_to_center = (unit_size - ImGui::CalcTextSize("O").x) / 2;
    ImGui::SameLine(caption_max + index * space_size + offset_to_center);
    ImGui::TextColored(ImGuiWrapper::to_ImVec4(ColorRGBA::X()),"X");
    ImGui::SameLine(caption_max + unit_size + (++index) * space_size + offset_to_center);
    ImGui::TextColored(ImGuiWrapper::to_ImVec4(ColorRGBA::Y()),"Y");
    ImGui::SameLine(caption_max + (++index_unit) * unit_size + (++index) * space_size + offset_to_center);
    ImGui::TextColored(ImGuiWrapper::to_ImVec4(ColorRGBA::Z()),"Z");
 
    index      = 1;
    index_unit = 1;
    ImGui::AlignTextToFramePadding();
    if (selection.is_single_full_instance() && is_instance_coordinates()) {
        imgui_wrapper->text(_L("Relative")); // ORCA
    }
    else {
        imgui_wrapper->text(_L("Position"));
    }
 
    ImGui::SameLine(caption_max + index * space_size);
    ImGui::PushItemWidth(unit_size);
    ImGui::BBLInputDouble(label_values[0][0], &display_position[0], 0.0f, 0.0f, "%.2f");
    ImGui::SameLine(caption_max + unit_size + (++index) * space_size);
    ImGui::PushItemWidth(unit_size);
    ImGui::BBLInputDouble(label_values[0][1], &display_position[1], 0.0f, 0.0f, "%.2f");
    ImGui::SameLine(caption_max + (++index_unit) * unit_size + (++index) * space_size);
    ImGui::PushItemWidth(unit_size);
    ImGui::BBLInputDouble(label_values[0][2], &display_position[2], 0.0f, 0.0f, "%.2f");
    ImGui::SameLine(caption_max + (++index_unit) * unit_size + (++index) * space_size);
    imgui_wrapper->text(this->m_new_unit_string);
    bool is_avoid_one_update{false};
    if (combox_changed) {
        combox_changed = false;
        set_coordinates_type((ECoordinatesType) selection_idx);
        UpdateAndShow(true);
        is_avoid_one_update = true; // avoid update(current_active_id, "position", original_position
    }
 
    if (!is_avoid_one_update) {
        for (int i = 0; i < display_position.size(); i++) {
            if (display_position[i] > MAX_NUM) display_position[i] = MAX_NUM;
            if (display_position[i] < -MAX_NUM) display_position[i] = -MAX_NUM;
        }
        m_buffered_position = display_position;
        update(current_active_id, "position", original_position, m_buffered_position);
    }
    // the init position values are not zero, won't add reset button
 
    // send focus to m_glcanvas
    bool focued_on_text = false;
    for (int j = 0; j < 3; j++) {
        unsigned int id = ImGui::GetID(label_values[0][j]);
        if (current_active_id == id) {
            m_glcanvas.handle_sidebar_focus_event(label_values[0][j] + 2, true);
            focued_on_text = true;
            break;
        }
    }
    if (!focued_on_text) m_glcanvas.handle_sidebar_focus_event("", false);
 
    // Align and distribute along the coordinate system of the panel, within the selection or to the object or plate holding it.
    using AlignType                = GLGizmoAlignment::AlignType;
    const bool old_align_to_parent = m_align_to_parent;
    AlignType  hovered_align_type  = AlignType::NONE;
    if (show_align) {
        ImGui::Spacing();
        ImGui::Separator();
        ImGui::Spacing();
        m_alignment_helper.set_object_cs(is_instance_coordinates());
 
        // Each row is row_height tall, separated by ItemSpacing.y. Every control is centered vertically in its row.
        const float       row_y         = ImGui::GetCursorPosY();
        const float       button_height = align_icon_size + 2.f * style.FramePadding.y;
        ImGuiWrapper::push_combo_style(m_glcanvas.get_scale());
        const float combo_height = ImGui::GetFrameHeight();
        ImGuiWrapper::pop_combo_style();
        const float row_height = std::max({ImGui::GetTextLineHeight(), button_height, combo_height});
        const float row_gap    = style.ItemSpacing.y;
        int         row        = 0;
        auto row_top       = [&](int r) { return row_y + r * (row_height + row_gap); };
        // Snap to whole pixels to avoid blurry icons
        auto center_in_row = [&](int r, float item_height) { return std::floor(row_top(r) + (row_height - item_height) * 0.5f); };
 
        // Row 0: align mode combo in the caption column.
        ImGui::SetCursorPosY(center_in_row(row, combo_height));
 
        // The last mode aligns to the parent. Aligning within the selection needs two items.
        std::vector<std::string> align_modes = {
            _u8L("Selection"),
            m_alignment_helper.is_parts_selection(true) ? _u8L("Object") : _u8L("Plate")
        };
        // Selecting enough items to align within them makes that the default, as when the tool opens.
        const bool can_align_within = m_alignment_helper.can_align(AlignType::X_MIN);
        if (can_align_within != m_can_align_within) {
            m_can_align_within = can_align_within;
            m_align_to_parent  = !can_align_within;
        }
        if (!can_align_within) {
            align_modes.erase(align_modes.begin());
            m_align_to_parent = true;
        }
        size_t align_mode_idx = m_align_to_parent ? align_modes.size() - 1 : 0;
        ImGuiWrapper::push_combo_style(m_glcanvas.get_scale());
        // render_combo() takes its ImGui id from the empty label, which the coordinate combo uses too.
        ImGui::PushID("align_mode");
        if (render_combo(imgui_wrapper, "", align_modes, align_mode_idx, 0, coord_combo_width))
            m_align_to_parent = align_mode_idx + 1 == align_modes.size();
        ImGui::PopID();
        ImGuiWrapper::pop_combo_style();
        // After pop_combo_style(): its light popup background would hide the tooltip's white text.
        if (ImGui::IsItemHovered()) {
            wxString tooltip_str = _L("Reference for alignment");
            imgui_wrapper->tooltip(tooltip_str, imgui_wrapper->calc_text_size(tooltip_str).x + 3 * space_size);
        }
 
        const bool dark_mode    = wxGetApp().dark_mode();
        int        current_axis = -1;
        auto align_icon = [&](int axis, AlignType type, GLGizmosManager::MENU_ICON_NAME icon,
                              GLGizmosManager::MENU_ICON_NAME dark_icon, const wxString &tip) {
            const bool distribute = type >= AlignType::DISTRIBUTE_X;
            const bool enabled    = m_align_to_parent ? m_alignment_helper.can_align(type, true) :
                                    distribute        ? m_alignment_helper.can_distribute(type) :
                                                        m_alignment_helper.can_align(type);
            if (axis != current_axis) {
                ImGui::SameLine(int(caption_max + (axis + 1) * space_size + axis * unit_size)); // ORCA ensure placement snaps to pixel to fix blur
                if (current_axis < 0)
                    ImGui::SetCursorPosY(center_in_row(row, button_height));
                current_axis = axis;
            } else
                ImGui::SameLine(0, 0);
 
            if (!enabled) {
                ImGui::PushStyleVar(ImGuiStyleVar_Alpha, 0.3f);
                ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImGui::GetStyle().Colors[ImGuiCol_Button]);
                ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImGui::GetStyle().Colors[ImGuiCol_Button]);
            }
            ImTextureID texture = m_glcanvas.get_gizmos_manager().get_icon_texture_id(dark_mode ? dark_icon : icon);
            if (ImGui::ImageButton3(texture, texture, ImVec2(align_icon_size, align_icon_size)) && enabled) {
                if (distribute)
                    m_alignment_helper.distribute_objects(type);
                else
                    m_alignment_helper.align_objects(type, m_align_to_parent);
            }
            if (!enabled) {
                ImGui::PopStyleColor(2);
                ImGui::PopStyleVar();
            }
 
            if (ImGui::IsItemHovered()) {
                wxString text = tip;
                if (enabled)
                    hovered_align_type = type;
                else {
                    // Too few items is the reason when there are items to move (only distribute needs three);
                    // otherwise the helper names it.
                    std::string why_not;
                    if (m_alignment_helper.get_items_count(type, m_align_to_parent, &why_not) > 0)
                        why_not = _u8L("Select at least 3 parts or objects");
                    if (!why_not.empty())
                        text += "\n" + from_u8(why_not);
                }
                imgui_wrapper->tooltip(text, imgui_wrapper->calc_text_size(text).x + 3 * space_size);
            }
        };
        ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 0.0f);
        align_icon(0, AlignType::X_MIN, GLGizmosManager::IC_ALIGN_X_MIN, GLGizmosManager::IC_ALIGN_X_MIN_DARK, _L("Align left") + " (-X)");
        align_icon(0, AlignType::CENTER_X, GLGizmosManager::IC_ALIGN_X_CENTER, GLGizmosManager::IC_ALIGN_X_CENTER_DARK, _L("Align left-right center") + " (X)");
        align_icon(0, AlignType::X_MAX, GLGizmosManager::IC_ALIGN_X_MAX, GLGizmosManager::IC_ALIGN_X_MAX_DARK, _L("Align right") + " (+X)");
 
        align_icon(1, AlignType::Y_MIN, GLGizmosManager::IC_ALIGN_Y_MIN, GLGizmosManager::IC_ALIGN_Y_MIN_DARK, _L("Align front") + " (-Y)");
        align_icon(1, AlignType::CENTER_Y, GLGizmosManager::IC_ALIGN_Y_CENTER, GLGizmosManager::IC_ALIGN_Y_CENTER_DARK, _L("Align front-back center") + " (Y)");
        align_icon(1, AlignType::Y_MAX, GLGizmosManager::IC_ALIGN_Y_MAX, GLGizmosManager::IC_ALIGN_Y_MAX_DARK, _L("Align back") + " (+Y)");
 
        align_icon(2, AlignType::Z_MIN, GLGizmosManager::IC_ALIGN_Z_MIN, GLGizmosManager::IC_ALIGN_Z_MIN_DARK, _L("Align bottom") + " (-Z)");
        align_icon(2, AlignType::CENTER_Z, GLGizmosManager::IC_ALIGN_Z_CENTER, GLGizmosManager::IC_ALIGN_Z_CENTER_DARK, _L("Align top-bottom center") + " (Z)");
        align_icon(2, AlignType::Z_MAX, GLGizmosManager::IC_ALIGN_Z_MAX, GLGizmosManager::IC_ALIGN_Z_MAX_DARK, _L("Align top") + " (+Z)");
 
        if (!m_align_to_parent) {
            row          = 1;
            current_axis = -1;
            ImGui::SetCursorPosY(center_in_row(row, ImGui::GetTextLineHeight()));
            imgui_wrapper->text(_L("Distribute"));
            align_icon(0, AlignType::DISTRIBUTE_X, GLGizmosManager::IC_DISTRIBUTE_X, GLGizmosManager::IC_DISTRIBUTE_X_DARK, _L("Distribute left-right") + " (X)");
            align_icon(1, AlignType::DISTRIBUTE_Y, GLGizmosManager::IC_DISTRIBUTE_Y, GLGizmosManager::IC_DISTRIBUTE_Y_DARK, _L("Distribute front-back") + " (Y)");
            align_icon(2, AlignType::DISTRIBUTE_Z, GLGizmosManager::IC_DISTRIBUTE_Z, GLGizmosManager::IC_DISTRIBUTE_Z_DARK, _L("Distribute top-bottom") + " (Z)");
        }
        ImGui::PopStyleVar();
        ImGui::SetCursorPosY(row_top(row + 1));
    }
    // The Move gizmo draws the preview with the scene, which an ImGui-only frame does not redraw.
    if (hovered_align_type != m_hovered_align_type || m_align_to_parent != old_align_to_parent) {
        m_hovered_align_type = hovered_align_type;
        m_glcanvas.set_as_dirty();
        m_glcanvas.request_extra_frame();
    }
 
    ImGui::Spacing();
    ImGui::Separator();
    ImGui::Spacing();
    float f_scale = m_glcanvas.get_gizmos_manager().get_layout_scale();
    ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(6.0f, 4.0f * f_scale));
 
    GLGizmoUtils::render_tooltip_button(imgui_wrapper, m_glcanvas, m_shortcuts_move, x, y);
 
    // ORCA use existing function for drop and show button on bottom bar to keep gizmo compact
    imgui_wrapper->disabled_begin(!m_enable_drop_to_bed);
    ImGui::SameLine(0, space_size * 1.5f);
    if (imgui_wrapper->button(_L("Drop"))){
        wxGetApp().plater()->drop_selection();
        UpdateAndShow(true);
    }
    imgui_wrapper->disabled_end();
    if(ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenDisabled))
        imgui_wrapper->tooltip(_L("Move the selection along Z so that its lowest point touches the bed."), ImGui::GetFontSize() * 20.0f);
 
    ImGui::SameLine();
    GLGizmoUtils::begin_right_aligned_buttons({ _L("Done") });
    if (imgui_wrapper->button(_L("Done"))) {
        m_glcanvas.reset_all_gizmos();
    }
 
    m_last_active_item = current_active_id;
    last_move_input_window_width = ImGui::GetWindowWidth();
    ImGui::PopStyleVar();
    imgui_wrapper->end();
    ImGui::PopStyleVar();
    ImGuiWrapper::pop_toolbar_style();
}

References _L, _u8L, Slic3r::GUI::ImGuiWrapper::begin(), Slic3r::GUI::GLGizmoUtils::begin_right_aligned_buttons(), Slic3r::GUI::ImGuiWrapper::button(), Slic3r::GUI::ImGuiWrapper::calc_text_size(), Slic3r::GUI::GLCanvas3D::CanvasView3D, Slic3r::GUI::ImGuiWrapper::disabled_begin(), Slic3r::GUI::ImGuiWrapper::disabled_end(), Slic3r::GUI::DPI_DEFAULT, Slic3r::GUI::ImGuiWrapper::end(), Slic3r::GUI::from_u8(), Slic3r::GUI::get_dpi_for_window(), Slic3r::GUI::ImGuiWrapper::get_style_scaling(), Slic3r::GUI::GLGizmosManager::IC_ALIGN_X_CENTER, Slic3r::GUI::GLGizmosManager::IC_ALIGN_X_CENTER_DARK, Slic3r::GUI::GLGizmosManager::IC_ALIGN_X_MAX, Slic3r::GUI::GLGizmosManager::IC_ALIGN_X_MAX_DARK, Slic3r::GUI::GLGizmosManager::IC_ALIGN_X_MIN, Slic3r::GUI::GLGizmosManager::IC_ALIGN_X_MIN_DARK, Slic3r::GUI::GLGizmosManager::IC_ALIGN_Y_CENTER, Slic3r::GUI::GLGizmosManager::IC_ALIGN_Y_CENTER_DARK, Slic3r::GUI::GLGizmosManager::IC_ALIGN_Y_MAX, Slic3r::GUI::GLGizmosManager::IC_ALIGN_Y_MAX_DARK, Slic3r::GUI::GLGizmosManager::IC_ALIGN_Y_MIN, Slic3r::GUI::GLGizmosManager::IC_ALIGN_Y_MIN_DARK, Slic3r::GUI::GLGizmosManager::IC_ALIGN_Z_CENTER, Slic3r::GUI::GLGizmosManager::IC_ALIGN_Z_CENTER_DARK, Slic3r::GUI::GLGizmosManager::IC_ALIGN_Z_MAX, Slic3r::GUI::GLGizmosManager::IC_ALIGN_Z_MAX_DARK, Slic3r::GUI::GLGizmosManager::IC_ALIGN_Z_MIN, Slic3r::GUI::GLGizmosManager::IC_ALIGN_Z_MIN_DARK, Slic3r::GUI::GLGizmosManager::IC_DISTRIBUTE_X, Slic3r::GUI::GLGizmosManager::IC_DISTRIBUTE_X_DARK, Slic3r::GUI::GLGizmosManager::IC_DISTRIBUTE_Y, Slic3r::GUI::GLGizmosManager::IC_DISTRIBUTE_Y_DARK, Slic3r::GUI::GLGizmosManager::IC_DISTRIBUTE_Z, Slic3r::GUI::GLGizmosManager::IC_DISTRIBUTE_Z_DARK, is_instance_coordinates(), Slic3r::GUI::Selection::is_multiple_full_object(), Slic3r::GUI::Selection::is_single_full_instance(), Slic3r::GUI::Selection::is_wipe_tower(), Slic3r::GUI::label_values, last_move_input_window_width, m_align_to_parent, m_alignment_helper, m_buffered_position, m_can_align_within, m_coordinates_type, m_enable_drop_to_bed, m_glcanvas, m_hovered_align_type, m_imperial_units, m_last_active_item, m_new_position, m_new_title_string, m_new_unit_string, m_shortcuts_move, MAX_NUM, MAX_SIZE, mm_to_in, on_change(), Slic3r::GUI::ImGuiWrapper::pop_combo_style(), Slic3r::GUI::ImGuiWrapper::pop_toolbar_style(), Slic3r::GUI::ImGuiWrapper::push_combo_style(), Slic3r::GUI::ImGuiWrapper::push_toolbar_style(), render_combo(), Slic3r::GUI::GLGizmoUtils::render_tooltip_button(), scale(), Slic3r::GUI::ImGuiWrapper::scaled(), set_coordinates_type(), Slic3r::GUI::ImGuiWrapper::set_next_window_pos(), style, Slic3r::GUI::ImGuiWrapper::text(), Slic3r::GUI::ImGuiWrapper::to_ImVec4(), Slic3r::GUI::ImGuiWrapper::TOOLBAR_WINDOW_FLAGS, Slic3r::GUI::ImGuiWrapper::tooltip(), UpdateAndShow(), Slic3r::GUI::World, Slic3r::ColorRGBA::X(), Slic3r::ColorRGBA::Y(), and Slic3r::ColorRGBA::Z().

Here is the call graph for this function:

do_render_rotate_window()

void Slic3r::GUI::GizmoObjectManipulation::do_render_rotate_window	(	ImGuiWrapper *	imgui_wrapper,
		std::string	window_name,
		float	x,
		float	y,
		float	bottom_limit )

{
    // BBS: GUI refactor: move gizmo to the right
    if (abs(last_rotate_input_window_width) > 0.01f) {
        if (x + last_rotate_input_window_width > m_glcanvas.get_canvas_size().get_width()) {
            if (last_rotate_input_window_width > m_glcanvas.get_canvas_size().get_width())
                x = 0;
            else
                x = m_glcanvas.get_canvas_size().get_width() - last_rotate_input_window_width;
        }
    }
#if BBS_TOOLBAR_ON_TOP
    imgui_wrapper->set_next_window_pos(x, y, ImGuiCond_Always, 0.f, 0.0f);
#else
    imgui_wrapper->set_next_window_pos(x, y, ImGuiCond_Always, 1.0f, 0.0f);
#endif
 
    // BBS
    ImGuiWrapper::push_toolbar_style(m_glcanvas.get_scale());
    ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(0.0, 6.0));
 
    std::string name = this->m_new_title_string + "##" + window_name;
    imgui_wrapper->begin(_L(name), ImGuiWrapper::TOOLBAR_WINDOW_FLAGS);
 
    auto update = [this](unsigned int active_id, std::string opt_key, Vec3d original_value, Vec3d new_value) -> int {
        for (int i = 0; i < 3; i++) {
            if (original_value[i] != new_value[i]) {
                if (active_id != m_last_active_item) {
                    on_change(opt_key, i, new_value[i]);
                    return i;
                }
            }
        }
        return -1;
    };
 
    float space_size    = imgui_wrapper->get_style_scaling() * 8;
    // ORCA
    float caption_max = std::max({
        imgui_wrapper->calc_text_size(_L("Relative")).x,
        imgui_wrapper->calc_text_size(_L("Absolute")).x,
        imgui_wrapper->calc_text_size(_L("World")).x
        //imgui_wrapper->calc_text_size(_L("Object")).x,
        //imgui_wrapper->calc_text_size(_L("Part")).x
    }) + 3.f * space_size;
    float end_text_size = ImGui::CalcTextSize("°").x; // ORCA rotate gizmo not uses mm or inch
 
    // position
    Vec3d original_position;
    if (this->m_imperial_units)
        original_position = this->m_new_position * this->mm_to_in;
    else
        original_position = this->m_new_position;
    Vec3d display_position = m_buffered_position;
    // Rotation
    Vec3d rotation   = this->m_buffered_rotation;
    Vec3d absolute_rotation = this->m_buffered_absolute_rotation;
    float unit_size = imgui_wrapper->calc_text_size(MAX_SIZE).x + space_size;
    int   index      = 1;
    int   index_unit = 1;
 
    ImGui::AlignTextToFramePadding();
    unsigned int current_active_id = ImGui::GetActiveID();
    ImGui::PushItemWidth(caption_max);
    imgui_wrapper->text(_L("World")); // ORCA
    if (ImGui::IsItemHovered()) {
        auto tooltip_str = _L("Coordinate system used for transform actions.");
        imgui_wrapper->tooltip(tooltip_str, imgui_wrapper->calc_text_size(tooltip_str).x + 3 * space_size);
    }
    // ORCA use TextColored to match axes color
    float offset_to_center = (unit_size - ImGui::CalcTextSize("O").x) / 2;
    ImGui::SameLine(caption_max + index * space_size + offset_to_center);
    ImGui::TextColored(ImGuiWrapper::to_ImVec4(ColorRGBA::X()),"X");
    ImGui::SameLine(caption_max + unit_size + (++index) * space_size + offset_to_center);
    ImGui::TextColored(ImGuiWrapper::to_ImVec4(ColorRGBA::Y()),"Y");
    ImGui::SameLine(caption_max + (++index_unit) * unit_size + (++index) * space_size + offset_to_center);
    ImGui::TextColored(ImGuiWrapper::to_ImVec4(ColorRGBA::Z()),"Z");
 
    index      = 1;
    index_unit = 1;
 
    // ImGui::PushItemWidth(unit_size * 2);
    bool is_relative_input = false;
    ImGui::AlignTextToFramePadding();
    imgui_wrapper->text(_L("Relative")); // ORCA
    ImGui::SameLine(caption_max + index * space_size);
    ImGui::PushItemWidth(unit_size);
    if (ImGui::BBLInputDouble(label_values[1][0], &rotation[0], 0.0f, 0.0f, "%.2f")) {
        is_relative_input = true;
    }
    ImGui::SameLine(caption_max + unit_size + (++index) * space_size);
    ImGui::PushItemWidth(unit_size);
    if (ImGui::BBLInputDouble(label_values[1][1], &rotation[1], 0.0f, 0.0f, "%.2f")) {
        is_relative_input = true;
    }
    ImGui::SameLine(caption_max + (++index_unit) * unit_size + (++index) * space_size);
    ImGui::PushItemWidth(unit_size);
    if (ImGui::BBLInputDouble(label_values[1][2], &rotation[2], 0.0f, 0.0f, "%.2f")) {
        is_relative_input = true;
    }
    ImGui::SameLine(caption_max + (++index_unit) * unit_size + (++index) * space_size);
    imgui_wrapper->text("°");
    m_buffered_rotation = rotation;
    if (is_relative_input) {
        m_last_rotate_type = RotateType::Relative;
    }
    if (m_last_rotate_type == RotateType::Relative) {
        bool is_valid = update(current_active_id, "rotation", this->m_new_rotation, m_buffered_rotation) >= 0;
        if (is_valid) {
            m_last_rotate_type = RotateType::None;
        }
    }
 
    ImGui::SameLine(caption_max + index_unit * unit_size + (++index) * space_size + end_text_size);
    if (reset_button(imgui_wrapper, m_show_clear_rotation)) // ORCA reserve icon space to prevent changes on layout
        reset_rotation_value(true);
    if (m_show_clear_rotation && ImGui::IsItemHovered()) {
        float tooltip_size = imgui_wrapper->calc_text_size(_L("Reset current rotation to the value when open the rotation tool.")).x + 3 * space_size;
        imgui_wrapper->tooltip(_u8L("Reset current rotation to the value when open the rotation tool."), tooltip_size);
    }
 
    // send focus to m_glcanvas
    bool focued_on_text = false;
    for (int j = 0; j < 3; j++) {
        unsigned int id = ImGui::GetID(label_values[1][j]);
        if (current_active_id == id) {
            m_glcanvas.handle_sidebar_focus_event(label_values[1][j] + 2, true);
            focued_on_text = true;
            break;
        }
    }
 
    index      = 1;
    index_unit = 1;
    ImGui::AlignTextToFramePadding();
    imgui_wrapper->text(_L("Absolute"));
    ImGui::SameLine(caption_max + index * space_size);
    ImGui::PushItemWidth(unit_size);
    bool is_absolute_input = false;
    if (ImGui::BBLInputDouble(label_values[2][0], &absolute_rotation[0], 0.0f, 0.0f, "%.2f")) {
        is_absolute_input = true;
    }
    ImGui::SameLine(caption_max + unit_size + (++index) * space_size);
    ImGui::PushItemWidth(unit_size);
    if (ImGui::BBLInputDouble(label_values[2][1], &absolute_rotation[1], 0.0f, 0.0f, "%.2f")) {
        is_absolute_input = true;
    }
    ImGui::SameLine(caption_max + (++index_unit) * unit_size + (++index) * space_size);
    ImGui::PushItemWidth(unit_size);
    if (ImGui::BBLInputDouble(label_values[2][2], &absolute_rotation[2], 0.0f, 0.0f, "%.2f")) {
        is_absolute_input = true;
    }
    ImGui::SameLine(caption_max + (++index_unit) * unit_size + (++index) * space_size);
    imgui_wrapper->text("°");
    m_buffered_absolute_rotation = absolute_rotation;
    if (is_absolute_input) {
        m_last_rotate_type = RotateType::Absolute;
    }
    if (m_last_rotate_type == RotateType::Absolute) {
        bool is_valid = update(current_active_id, "absolute_rotation", this->m_new_absolute_rotation, m_buffered_absolute_rotation) >= 0;
        if (is_valid) {
            m_last_rotate_type = RotateType::None;
        }
    }
 
    ImGui::SameLine(caption_max + index_unit * unit_size + (++index) * space_size + end_text_size);
    if (reset_zero_button(imgui_wrapper, m_show_reset_0_rotation)) // ORCA reserve icon space to prevent changes on layout
        reset_rotation_value(false);
    if (m_show_reset_0_rotation && ImGui::IsItemHovered()) {
        float tooltip_size = imgui_wrapper->calc_text_size(_L("Reset current rotation to real zeros.")).x + 3 * space_size;
        imgui_wrapper->tooltip(_L("Reset current rotation to real zeros."), tooltip_size);
    }
    // send focus to m_glcanvas
    bool absolute_focued_on_text = false;
    for (int j = 0; j < 3; j++) {
        unsigned int id = ImGui::GetID(label_values[2][j]);
        if (current_active_id == id) {
            m_glcanvas.handle_sidebar_focus_event(label_values[2][j] + 2, true);
            absolute_focued_on_text = true;
            break;
        }
    }
    if (!focued_on_text  && !absolute_focued_on_text)
        m_glcanvas.handle_sidebar_focus_event("", false);
 
    ImGui::Spacing(); // needed after Text
    ImGui::Separator();
    ImGui::Spacing();
    float f_scale = m_glcanvas.get_gizmos_manager().get_layout_scale();
    ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(6.0f, 4.0f * f_scale));
 
    GLGizmoUtils::render_tooltip_button(imgui_wrapper, m_glcanvas, m_shortcuts_rotate, x, y);
    
    ImGui::SameLine();
    GLGizmoUtils::begin_right_aligned_buttons({ _L("Done") });
    if (imgui_wrapper->button(_L("Done"))) {
        m_glcanvas.reset_all_gizmos();
    }
 
    m_last_active_item = current_active_id;
    last_rotate_input_window_width = ImGui::GetWindowWidth();
    ImGui::PopStyleVar();
    imgui_wrapper->end();
 
    // BBS
    ImGui::PopStyleVar();
    ImGuiWrapper::pop_toolbar_style();
}

References _L, _u8L, Absolute, Slic3r::GUI::ImGuiWrapper::begin(), Slic3r::GUI::GLGizmoUtils::begin_right_aligned_buttons(), Slic3r::GUI::ImGuiWrapper::button(), Slic3r::GUI::ImGuiWrapper::calc_text_size(), Slic3r::GUI::ImGuiWrapper::end(), Slic3r::GUI::ImGuiWrapper::get_style_scaling(), Slic3r::GUI::label_values, last_rotate_input_window_width, m_buffered_absolute_rotation, m_buffered_position, m_buffered_rotation, m_glcanvas, m_imperial_units, m_last_active_item, m_last_rotate_type, m_new_absolute_rotation, m_new_position, m_new_rotation, m_new_title_string, m_shortcuts_rotate, m_show_clear_rotation, m_show_reset_0_rotation, MAX_SIZE, mm_to_in, None, on_change(), Slic3r::GUI::ImGuiWrapper::pop_toolbar_style(), Slic3r::GUI::ImGuiWrapper::push_toolbar_style(), Relative, Slic3r::GUI::GLGizmoUtils::render_tooltip_button(), reset_button(), reset_rotation_value(), reset_zero_button(), Slic3r::GUI::ImGuiWrapper::set_next_window_pos(), Slic3r::GUI::ImGuiWrapper::text(), Slic3r::GUI::ImGuiWrapper::to_ImVec4(), Slic3r::GUI::ImGuiWrapper::TOOLBAR_WINDOW_FLAGS, Slic3r::GUI::ImGuiWrapper::tooltip(), Slic3r::ColorRGBA::X(), Slic3r::ColorRGBA::Y(), and Slic3r::ColorRGBA::Z().

Here is the call graph for this function:

do_render_scale_input_window()

void Slic3r::GUI::GizmoObjectManipulation::do_render_scale_input_window	(	ImGuiWrapper *	imgui_wrapper,
		std::string	window_name,
		float	x,
		float	y,
		float	bottom_limit )

{
    //BBS: GUI refactor: move gizmo to the right
    if (abs(last_scale_input_window_width) > 0.01f) {
        if (x + last_scale_input_window_width > m_glcanvas.get_canvas_size().get_width()) {
            if (last_scale_input_window_width > m_glcanvas.get_canvas_size().get_width())
                x = 0;
            else
                x = m_glcanvas.get_canvas_size().get_width() - last_scale_input_window_width;
        }
    }
#if BBS_TOOLBAR_ON_TOP
    imgui_wrapper->set_next_window_pos(x, y, ImGuiCond_Always, 0.f, 0.0f);
#else
    imgui_wrapper->set_next_window_pos(x, y, ImGuiCond_Always, 1.0f, 0.0f);
#endif
 
    //BBS
    ImGuiWrapper::push_toolbar_style(m_glcanvas.get_scale());
    ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(0.0, 6.0));
 
    std::string name = this->m_new_title_string + "##" + window_name;
    imgui_wrapper->begin(_L(name), ImGuiWrapper::TOOLBAR_WINDOW_FLAGS);
 
    auto update = [this](unsigned int active_id, std::string opt_key, Vec3d original_value, Vec3d new_value)->int {
        for (int i = 0; i < 3; i++)
        {
            if (original_value[i] != new_value[i])
            {
                if (active_id != m_last_active_item)
                {
                    on_change(opt_key, i, new_value[i]);
                    return i;
                }
            }
        }
        return -1;
    };
 
    float space_size = imgui_wrapper->get_style_scaling() * 8;
    // ORCA
    float coord_combo_width = std::max({
        imgui_wrapper->calc_text_size(_L("World")).x,
        imgui_wrapper->calc_text_size(_L("Object")).x,
        imgui_wrapper->calc_text_size(_L("Part")).x
    }) + imgui_wrapper->calc_text_size("xxx"sv).x + imgui_wrapper->scaled(3.5f);
    float label_max = std::max({
        imgui_wrapper->calc_text_size(_L_CONTEXT("Scale", "Noun")).x,
        imgui_wrapper->calc_text_size(_L("Size")).x
    });
    float caption_max = std::max(label_max, coord_combo_width - 3 * space_size);
    float end_text_size = imgui_wrapper->calc_text_size(this->m_new_unit_string).x;
    ImGui::AlignTextToFramePadding();
    unsigned int current_active_id = ImGui::GetActiveID();
 
    Vec3d scale = m_buffered_scale;
    Vec3d display_size = m_buffered_size;
 
    Vec3d display_position = m_buffered_position;
 
    float unit_size = imgui_wrapper->calc_text_size(MAX_SIZE).x + space_size;
    bool imperial_units = this->m_imperial_units;
 
    int index      = 2;
    int index_unit = 1;
 
    Selection &              selection = m_glcanvas.get_selection();
    std::vector<std::string> modes     = {_u8L("World"), _u8L("Object"), _u8L("Part")}; // ORCA use shorter terms to make UI more compact
    if (selection.is_single_full_object()) { modes.pop_back(); }
    if (selection.is_multiple_full_object()) {
        modes.pop_back();
        modes.pop_back();
    }
    size_t selection_idx = (int) m_coordinates_type;
    if (selection_idx >= modes.size()) {
        set_coordinates_type(ECoordinatesType::World);
        selection_idx = 0;
    }
 
    ImGuiWrapper::push_combo_style(m_glcanvas.get_scale());
    bool combox_changed = false;
    if (render_combo(imgui_wrapper, "", modes, selection_idx, 0, coord_combo_width)) {
        combox_changed = true;
    }
    ImGuiWrapper::pop_combo_style();
    // After pop_combo_style(): its light popup background would hide the tooltip's white text.
    if (ImGui::IsItemHovered()) {
        auto tooltip_str = _L("Coordinate system used for transform actions.");
        imgui_wrapper->tooltip(tooltip_str, imgui_wrapper->calc_text_size(tooltip_str).x + 3 * space_size);
    }
 
    // ORCA use TextColored to match axes color
    float offset_to_center = (unit_size - ImGui::CalcTextSize("O").x) / 2;
    ImGui::SameLine(caption_max + space_size + offset_to_center);
    ImGui::TextColored(ImGuiWrapper::to_ImVec4(ColorRGBA::X()),"X");
    ImGui::SameLine(caption_max + unit_size + index * space_size + offset_to_center);
    ImGui::TextColored(ImGuiWrapper::to_ImVec4(ColorRGBA::Y()),"Y");
    ImGui::SameLine(caption_max + (++index_unit) * unit_size + (++index) * space_size + offset_to_center);
    ImGui::TextColored(ImGuiWrapper::to_ImVec4(ColorRGBA::Z()),"Z");
 
    index      = 2;
    index_unit = 1;
 
    //ImGui::PushItemWidth(unit_size * 2);
    ImGui::AlignTextToFramePadding();
    imgui_wrapper->text(_L_CONTEXT("Scale", "Noun"));
    ImGui::SameLine(caption_max + space_size);
    ImGui::PushItemWidth(unit_size);
    ImGui::BBLInputDouble(label_scale_values[0][0], &scale[0], 0.0f, 0.0f, "%.2f");
    ImGui::SameLine(caption_max + unit_size + index * space_size);
    ImGui::PushItemWidth(unit_size);
    ImGui::BBLInputDouble(label_scale_values[0][1], &scale[1], 0.0f, 0.0f, "%.2f");
    ImGui::SameLine(caption_max + (++index_unit) *unit_size + (++index) * space_size);
    ImGui::PushItemWidth(unit_size);
    ImGui::BBLInputDouble(label_scale_values[0][2], &scale[2], 0.0f, 0.0f, "%.2f");
    ImGui::SameLine(caption_max + (++index_unit) *unit_size + (++index) * space_size);
    imgui_wrapper->text("%");
    if (scale.x() > 0 && scale.y() > 0 && scale.z() > 0) {
        m_buffered_scale = scale;
    }
 
    ImGui::SameLine(caption_max + 3 * unit_size + 4 * space_size + end_text_size);
    if (reset_button(imgui_wrapper, m_show_clear_scale))
        reset_scale_value();
 
    //Size
    Vec3d original_size;
    if (this->m_imperial_units)
        original_size = this->m_new_size * this->mm_to_in;
    else
        original_size = this->m_new_size;
 
    index              = 2;
    index_unit         = 1;
    //ImGui::PushItemWidth(unit_size * 2);
    ImGui::AlignTextToFramePadding();
    imgui_wrapper->text(_L("Size"));
    ImGui::SameLine(caption_max + space_size);
    ImGui::PushItemWidth(unit_size);
    ImGui::BBLInputDouble(label_scale_values[1][0], &display_size[0], 0.0f, 0.0f, "%.2f");
    ImGui::SameLine(caption_max + unit_size + index * space_size);
    ImGui::PushItemWidth(unit_size);
    ImGui::BBLInputDouble(label_scale_values[1][1], &display_size[1], 0.0f, 0.0f, "%.2f");
    ImGui::SameLine(caption_max + (++index_unit) *unit_size + (++index) * space_size);
    ImGui::PushItemWidth(unit_size);
    ImGui::BBLInputDouble(label_scale_values[1][2], &display_size[2], 0.0f, 0.0f, "%.2f");
    ImGui::SameLine(caption_max + (++index_unit) *unit_size + (++index) * space_size);
    imgui_wrapper->text(this->m_new_unit_string);
    for (int i = 0; i < display_size.size(); i++) {
        if (std::abs(display_size[i]) > MAX_NUM) {
            display_size[i] = MAX_NUM;
        }
    }
    if (display_size.x() > 0 && display_size.y() > 0 && display_size.z() > 0) {
        m_buffered_size = display_size;
    }
 
    ImGui::AlignTextToFramePadding();
    bool is_avoid_one_update{false};
    if (combox_changed) {
        combox_changed = false;
        set_coordinates_type((ECoordinatesType) selection_idx);
        UpdateAndShow(true);
        is_avoid_one_update = true;
    }
 
    auto uniform_scale_size =imgui_wrapper->calc_text_size(_L("Uniform scale")).x;
    ImGui::PushItemWidth(uniform_scale_size);
    int size_sel{-1};
    if (!is_avoid_one_update) {
        size_sel    = update(current_active_id, "size", original_size, m_buffered_size);
    }
    ImGui::PopStyleVar(1);
    bool uniform_scale = this->m_uniform_scale;
 
    // BBS: when select multiple objects, uniform scale can be deselected
    //const Selection &selection = m_glcanvas.get_selection();
    //bool uniform_scale_only    = selection.is_multiple_full_object() || selection.is_multiple_full_instance() || selection.is_mixed() || selection.is_multiple_volume() ||
    //                          selection.is_multiple_modifier();
 
    //if (uniform_scale_only) {
    //    imgui_wrapper->disabled_begin(true);
    //    imgui_wrapper->bbl_checkbox(_L("Uniform scale"), uniform_scale_only);
    //    imgui_wrapper->disabled_end();
    //} else {
        imgui_wrapper->bbl_checkbox(_L("Uniform scale"), uniform_scale);
    //}
    if (uniform_scale != this->m_uniform_scale) { this->set_uniform_scaling(uniform_scale); }
 
     // for (int index = 0; index < 3; index++)
    //    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ",before_index="<<index <<boost::format(",scale %1%, buffered %2%, original_id %3%, new_id %4%\n") %
    //    this->m_new_scale[index] % m_buffered_scale[index] % m_last_active_item % current_active_id;
    int scale_sel = update(current_active_id, "scale", this->m_new_scale, m_buffered_scale);
    if ((scale_sel >= 0)) {
        // for (int index = 0; index < 3; index++)
        //    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ",after_index="<<index <<boost::format(",scale %1%, buffered %2%, original_id %3%, new_id %4%\n") %
        //    this->m_new_scale[index] % m_buffered_scale[index] % m_last_active_item % current_active_id;
        for (int i = 0; i < 3; ++i) {
            if (i != scale_sel) ImGui::ClearInputTextInitialData(label_scale_values[0][i], m_buffered_scale[i]);
            ImGui::ClearInputTextInitialData(label_scale_values[1][i], m_buffered_size[i]);
        }
    }
 
    if ((size_sel >= 0)) {
        // for (int index = 0; index < 3; index++)
        //    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ",after_index="<<index <<boost::format(",scale %1%, buffered %2%, original_id %3%, new_id %4%\n") %
        //    this->m_new_scale[index] % m_buffered_scale[index] % m_last_active_item % current_active_id;
        for (int i = 0; i < 3; ++i) {
            ImGui::ClearInputTextInitialData(label_scale_values[0][i], m_buffered_scale[i]);
            if (i != size_sel) ImGui::ClearInputTextInitialData(label_scale_values[1][i], m_buffered_size[i]);
        }
    }
 
    //send focus to m_glcanvas
    bool focued_on_text = false;
    for (int i = 0; i < 2; i++)
        for (int j = 0; j < 3; j++)
        {
            unsigned int id = ImGui::GetID(label_scale_values[i][j]);
            if (current_active_id == id)
            {
                m_glcanvas.handle_sidebar_focus_event(label_scale_values[i][j] + 2, true);
                focued_on_text = true;
                break;
            }
        }
    if (!focued_on_text)
        m_glcanvas.handle_sidebar_focus_event("", false);
    
    ImGui::Separator();
    float f_scale = m_glcanvas.get_gizmos_manager().get_layout_scale();
    ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(6.0f, 4.0f * f_scale));
 
    GLGizmoUtils::render_tooltip_button(imgui_wrapper, m_glcanvas, m_shortcuts_scale, x, y);
 
    ImGui::SameLine();
    GLGizmoUtils::begin_right_aligned_buttons({ _L("Done") });
    if (imgui_wrapper->button(_L("Done"))) {
        m_glcanvas.reset_all_gizmos();
    }
 
    m_last_active_item = current_active_id;
 
    last_scale_input_window_width = ImGui::GetWindowWidth();
    imgui_wrapper->end();
 
    //BBS
    ImGui::PopStyleVar(1);
    ImGuiWrapper::pop_toolbar_style();
}

References _L, _L_CONTEXT, _u8L, Slic3r::GUI::ImGuiWrapper::bbl_checkbox(), Slic3r::GUI::ImGuiWrapper::begin(), Slic3r::GUI::GLGizmoUtils::begin_right_aligned_buttons(), Slic3r::GUI::ImGuiWrapper::button(), Slic3r::GUI::ImGuiWrapper::calc_text_size(), Slic3r::GUI::ImGuiWrapper::end(), Slic3r::GUI::ImGuiWrapper::get_style_scaling(), Slic3r::GUI::Selection::is_multiple_full_object(), Slic3r::GUI::Selection::is_single_full_object(), Slic3r::GUI::label_scale_values, last_scale_input_window_width, m_buffered_position, m_buffered_scale, m_buffered_size, m_coordinates_type, m_glcanvas, m_imperial_units, m_last_active_item, m_new_scale, m_new_size, m_new_title_string, m_new_unit_string, m_shortcuts_scale, m_show_clear_scale, m_uniform_scale, MAX_NUM, MAX_SIZE, mm_to_in, on_change(), Slic3r::GUI::ImGuiWrapper::pop_combo_style(), Slic3r::GUI::ImGuiWrapper::pop_toolbar_style(), Slic3r::GUI::ImGuiWrapper::push_combo_style(), Slic3r::GUI::ImGuiWrapper::push_toolbar_style(), render_combo(), Slic3r::GUI::GLGizmoUtils::render_tooltip_button(), reset_button(), reset_scale_value(), scale(), Slic3r::GUI::ImGuiWrapper::scaled(), set_coordinates_type(), Slic3r::GUI::ImGuiWrapper::set_next_window_pos(), set_uniform_scaling(), Slic3r::GUI::ImGuiWrapper::text(), Slic3r::GUI::ImGuiWrapper::to_ImVec4(), Slic3r::GUI::ImGuiWrapper::TOOLBAR_WINDOW_FLAGS, Slic3r::GUI::ImGuiWrapper::tooltip(), UpdateAndShow(), Slic3r::GUI::World, Slic3r::ColorRGBA::X(), Slic3r::ColorRGBA::Y(), and Slic3r::ColorRGBA::Z().

Here is the call graph for this function:

do_scale()

void Slic3r::GUI::GizmoObjectManipulation::do_scale ( int axis, const Vec3d & scale ) const

private

{
    Selection& selection = m_glcanvas.get_selection();
 
    TransformationType transformation_type;
    if (is_local_coordinates())
        transformation_type.set_local();
    else if (is_instance_coordinates())
        transformation_type.set_instance();
    if (selection.is_single_volume_or_modifier() && !is_local_coordinates())
        transformation_type.set_relative();
 
    Vec3d scaling_factor = m_uniform_scale ? scale(axis) * Vec3d::Ones() : scale;
    limit_scaling_ratio(scaling_factor);
 
    selection.setup_cache();
    selection.scale(scaling_factor, transformation_type);
    m_glcanvas.do_scale(L("Set scale"));
}

References is_instance_coordinates(), is_local_coordinates(), Slic3r::GUI::Selection::is_single_volume_or_modifier(), L, limit_scaling_ratio(), m_glcanvas, m_uniform_scale, scale(), Slic3r::GUI::Selection::scale(), Slic3r::GUI::TransformationType::set_instance(), Slic3r::GUI::TransformationType::set_local(), Slic3r::GUI::TransformationType::set_relative(), and Slic3r::GUI::Selection::setup_cache().

Referenced by change_scale_value(), and change_size_value().

Here is the call graph for this function:

Here is the caller graph for this function:

get_align_to_parent()

bool Slic3r::GUI::GizmoObjectManipulation::get_align_to_parent ( ) const

inline

{ return m_align_to_parent; }

References m_align_to_parent.

get_alignment_helper()

const GLGizmoAlignment & Slic3r::GUI::GizmoObjectManipulation::get_alignment_helper ( ) const

inline

{ return m_alignment_helper; }

References m_alignment_helper.

get_cache()

const Cache & Slic3r::GUI::GizmoObjectManipulation::get_cache ( )

inline

{return m_cache; }

References m_cache.

get_coordinates_type()

ECoordinatesType Slic3r::GUI::GizmoObjectManipulation::get_coordinates_type ( ) const

inline

{ return m_coordinates_type; }

References m_coordinates_type.

get_hovered_align_type()

GLGizmoAlignment::AlignType Slic3r::GUI::GizmoObjectManipulation::get_hovered_align_type ( ) const

inline

{ return m_hovered_align_type; }

References m_hovered_align_type.

get_uniform_scaling()

bool Slic3r::GUI::GizmoObjectManipulation::get_uniform_scaling ( ) const

inline

{ return m_uniform_scale; }

References m_uniform_scale.

get_use_object_cs()

bool Slic3r::GUI::GizmoObjectManipulation::get_use_object_cs ( )

inline

{ return m_use_object_cs; }

References m_use_object_cs.

is_instance_coordinates()

bool Slic3r::GUI::GizmoObjectManipulation::is_instance_coordinates ( ) const

inline

{ return m_coordinates_type == ECoordinatesType::Instance; }

References Slic3r::GUI::Instance, and m_coordinates_type.

Referenced by change_absolute_rotation_value(), change_rotation_value(), do_render_move_window(), do_scale(), and update_settings_value().

Here is the caller graph for this function:

is_local_coordinates()

bool Slic3r::GUI::GizmoObjectManipulation::is_local_coordinates ( ) const

inline

{ return m_coordinates_type == ECoordinatesType::Local; }

References Slic3r::GUI::Local, and m_coordinates_type.

Referenced by change_absolute_rotation_value(), change_rotation_value(), do_scale(), and update_settings_value().

Here is the caller graph for this function:

is_world_coordinates()

bool Slic3r::GUI::GizmoObjectManipulation::is_world_coordinates ( ) const

inline

{ return m_coordinates_type == ECoordinatesType::World; }

References m_coordinates_type, and Slic3r::GUI::World.

Referenced by change_size_value(), and update_settings_value().

Here is the caller graph for this function:

IsShown()

bool Slic3r::GUI::GizmoObjectManipulation::IsShown

(

)

limit_scaling_ratio()

void Slic3r::GUI::GizmoObjectManipulation::limit_scaling_ratio

(

Vec3d &

scaling_factor

)

const

                                                                            {
    for (size_t i = 0; i < scaling_factor.size(); i++) { // range protect //scaling_factor too big has problem
        if (scaling_factor[i] * m_unscale_size[i] > MAX_NUM) {
            scaling_factor[i] = MAX_NUM / m_unscale_size[i];
        }
    }
}

References m_unscale_size, and MAX_NUM.

Referenced by do_scale().

Here is the caller graph for this function:

max_unit_size()

float Slic3r::GUI::GizmoObjectManipulation::max_unit_size	(	int	number,
		Vec3d &	vec1,
		Vec3d &	vec2,
		std::string	str )

 {
     if (number <= 1) return -1;
     Vec3d vec[2] = {vec1, vec2};
     float nuit_max[4] = {0};
     float vec_max = 0, unit_size = 0;
 
     for (int i = 0; i < number; i++)
     {
         char buf[3][64] = {};
         float buf_size[3] = {0};
         for (int j = 0; j < 3; j++) {
             ImGui::DataTypeFormatString(buf[j], IM_ARRAYSIZE(buf[j]), ImGuiDataType_Double, (void *) &vec[i][j], "%.2f");
             buf_size[j]  = ImGui::CalcTextSize(buf[j]).x;
             vec_max = std::max(buf_size[j], vec_max);
             nuit_max[i]  = vec_max;
         }
         unit_size = std::max(nuit_max[i], unit_size);
     }
 
     return unit_size + 8.0;
 }

on_change()

void Slic3r::GUI::GizmoObjectManipulation::on_change	(	const std::string &	opt_key,
		int	axis,
		double	new_value )

{
    if (!m_cache.is_valid())
        return;
 
    if (m_imperial_units && (opt_key == "position" || opt_key == "size"))
        new_value *= in_to_mm;
 
    if (opt_key == "position")
        change_position_value(axis, new_value);
    else if (opt_key == "rotation")
        change_rotation_value(axis, new_value);
    else if (opt_key == "absolute_rotation")
        change_absolute_rotation_value(axis, new_value);
    else if (opt_key == "scale")
        change_scale_value(axis, new_value);
    else if (opt_key == "size")
        change_size_value(axis, new_value);
}

References change_absolute_rotation_value(), change_position_value(), change_rotation_value(), change_scale_value(), change_size_value(), in_to_mm, m_cache, and m_imperial_units.

Referenced by do_render_move_window(), do_render_rotate_window(), and do_render_scale_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

render_combo()

bool Slic3r::GUI::GizmoObjectManipulation::render_combo	(	ImGuiWrapper *	imgui_wrapper,
		const std::string &	label,
		const std::vector< std::string > &	lines,
		size_t &	selection_idx,
		float	label_width,
		float	item_width )

{
    if(!label.empty()){
        ImGui::AlignTextToFramePadding();
        imgui_wrapper->text(label);
        ImGui::SameLine(label_width);
    }
 
    ImGui::PushItemWidth(item_width);
 
    size_t selection_out = selection_idx;
 
    const char *selected_str = (selection_idx >= 0 && selection_idx < int(lines.size())) ? lines[selection_idx].c_str() : "";
    if (ImGui::BBLBeginCombo(("##" + label).c_str(), selected_str, 0)) {
        for (size_t line_idx = 0; line_idx < lines.size(); ++line_idx) {
            ImGui::PushID(int(line_idx));
            if (ImGui::Selectable("", line_idx == selection_idx)) selection_out = line_idx;
 
            ImGui::SameLine();
            ImGui::Text("%s", lines[line_idx].c_str());
            ImGui::PopID();
        }
 
        ImGui::EndCombo();
    }
 
    bool is_changed = selection_idx != selection_out;
    selection_idx   = selection_out;
 
    return is_changed;
}

References Slic3r::GUI::ImGuiWrapper::text().

Referenced by do_render_move_window(), and do_render_scale_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_align_state()

void Slic3r::GUI::GizmoObjectManipulation::reset_align_state

(

)

{
    m_hovered_align_type = GLGizmoAlignment::AlignType::NONE;
    m_can_align_within   = m_alignment_helper.can_align(GLGizmoAlignment::AlignType::X_MIN);
    m_align_to_parent    = !m_can_align_within;
}

References m_align_to_parent, m_alignment_helper, m_can_align_within, m_hovered_align_type, Slic3r::GUI::GLGizmoAlignment::NONE, and Slic3r::GUI::GLGizmoAlignment::X_MIN.

reset_button()

bool Slic3r::GUI::GizmoObjectManipulation::reset_button	(	ImGuiWrapper *	imgui_wrapper,
		bool	enabled )

{
    imgui_wrapper->disabled_begin(!enabled);
    bool        pressed   = false;
    ImTextureID normal_id = m_glcanvas.get_gizmos_manager().get_icon_texture_id(GLGizmosManager::MENU_ICON_NAME::IC_TOOLBAR_RESET);
    ImTextureID hover_id  = m_glcanvas.get_gizmos_manager().get_icon_texture_id(GLGizmosManager::MENU_ICON_NAME::IC_TOOLBAR_RESET_HOVER);
 
    float  scale       = m_glcanvas.get_scale();
    #ifdef WIN32
        int dpi = get_dpi_for_window(wxGetApp().GetTopWindow());
        scale *= (float) dpi / (float) DPI_DEFAULT;
    #endif // WIN32
    ImVec2 button_size = ImVec2(16 * scale, 16 * scale); // ORCA: Use exact resolution will prevent blur on icon
 
    ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 0.0f);
 
    pressed = ImGui::ImageButton3(normal_id, hover_id, button_size, {0,0}, {1,1}, -1, {0,0,0,0}, {1,1,1, enabled ? 1.f : 0.f});  // ORCA make icon invisible to prevent changes on layout
 
    ImGui::PopStyleVar(1);
 
    imgui_wrapper->disabled_end();
    return pressed;
}

References Slic3r::GUI::ImGuiWrapper::disabled_begin(), Slic3r::GUI::ImGuiWrapper::disabled_end(), Slic3r::GUI::DPI_DEFAULT, Slic3r::GUI::get_dpi_for_window(), Slic3r::GUI::GLGizmosManager::IC_TOOLBAR_RESET, Slic3r::GUI::GLGizmosManager::IC_TOOLBAR_RESET_HOVER, m_glcanvas, and scale().

Referenced by do_render_rotate_window(), and do_render_scale_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_cache()

void Slic3r::GUI::GizmoObjectManipulation::reset_cache ( )

inline

{ m_cache.reset(); }

References m_cache.

reset_position_value()

void Slic3r::GUI::GizmoObjectManipulation::reset_position_value ( )

private

{
    Selection& selection = m_glcanvas.get_selection();
 
    if (selection.is_single_volume() || selection.is_single_modifier()) {
        GLVolume* volume = const_cast<GLVolume*>(selection.get_first_volume());
        volume->set_volume_offset(Vec3d::Zero());
    }
    else if (selection.is_single_full_instance()) {
        for (unsigned int idx : selection.get_volume_idxs()) {
            GLVolume* volume = const_cast<GLVolume*>(selection.get_volume(idx));
            volume->set_instance_offset(Vec3d::Zero());
        }
    }
    else
        return;
 
    // Copy position values from GLVolumes into Model (ModelInstance / ModelVolume), trigger background processing.
    wxGetApp().plater()->take_snapshot(_u8L("Reset position"), UndoRedo::SnapshotType::GizmoAction);
    m_glcanvas.do_move("");
 
    UpdateAndShow(true);
}

References _u8L, Slic3r::GUI::Selection::get_first_volume(), Slic3r::GUI::Selection::get_volume(), Slic3r::GUI::Selection::get_volume_idxs(), Slic3r::UndoRedo::GizmoAction, Slic3r::GUI::Selection::is_single_full_instance(), Slic3r::GUI::Selection::is_single_modifier(), Slic3r::GUI::Selection::is_single_volume(), m_glcanvas, Slic3r::GLVolume::set_instance_offset(), Slic3r::GLVolume::set_volume_offset(), and UpdateAndShow().

Here is the call graph for this function:

reset_rotation_value()

void Slic3r::GUI::GizmoObjectManipulation::reset_rotation_value ( bool reset_relative )

private

{
    Selection &selection = m_glcanvas.get_selection();
    selection.setup_cache();
    if (selection.is_single_volume_or_modifier()) {
        GLVolume *               vol    = const_cast<GLVolume *>(selection.get_first_volume());
        Geometry::Transformation trafo  = vol->get_volume_transformation();
        if (reset_relative) {
            auto offset = trafo.get_offset();
            trafo.set_matrix(m_init_rotation_scale_tran);
            trafo.set_offset(offset);
        }
        else {
            trafo.reset_rotation();
        }
        vol->set_volume_transformation(trafo);
    } else if (selection.is_single_full_instance()) {
        Geometry::Transformation trafo  = selection.get_first_volume()->get_instance_transformation();
        if (reset_relative) {
            auto offset = trafo.get_offset();
            trafo.set_matrix(m_init_rotation_scale_tran);
            trafo.set_offset(offset);
        } else {
            trafo.reset_rotation();
        }
        for (unsigned int idx : selection.get_volume_idxs()) {
            const_cast<GLVolume *>(selection.get_volume(idx))->set_instance_transformation(trafo);
        }
    } else
        return;
    // Synchronize instances/volumes.
 
    selection.synchronize_unselected_instances(Selection::SyncRotationType::RESET);
    selection.synchronize_unselected_volumes();
    // Copy rotation values from GLVolumes into Model (ModelInstance / ModelVolume), trigger background processing.
    m_glcanvas.do_rotate(L("Reset rotation"));
 
    UpdateAndShow(true);
}

References Slic3r::GUI::Selection::get_first_volume(), Slic3r::GLVolume::get_instance_transformation(), Slic3r::Geometry::Transformation::get_offset(), Slic3r::GUI::Selection::get_volume(), Slic3r::GUI::Selection::get_volume_idxs(), Slic3r::GLVolume::get_volume_transformation(), Slic3r::GUI::Selection::is_single_full_instance(), Slic3r::GUI::Selection::is_single_volume_or_modifier(), L, m_glcanvas, m_init_rotation_scale_tran, Slic3r::offset(), Slic3r::GUI::Selection::RESET, Slic3r::Geometry::Transformation::reset_rotation(), Slic3r::GLVolume::set_instance_transformation(), Slic3r::Geometry::Transformation::set_matrix(), Slic3r::Geometry::Transformation::set_offset(), Slic3r::GLVolume::set_volume_transformation(), Slic3r::GUI::Selection::setup_cache(), Slic3r::GUI::Selection::synchronize_unselected_instances(), Slic3r::GUI::Selection::synchronize_unselected_volumes(), and UpdateAndShow().

Referenced by do_render_rotate_window().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_scale_value()

void Slic3r::GUI::GizmoObjectManipulation::reset_scale_value ( )

private

{
    Plater::TakeSnapshot snapshot(wxGetApp().plater(), "Reset scale");
 
    change_scale_value(0, 100.);
    change_scale_value(1, 100.);
    change_scale_value(2, 100.);
}

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

Referenced by do_render_scale_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_settings_value()

void Slic3r::GUI::GizmoObjectManipulation::reset_settings_value ( )

private

{
    m_new_position = Vec3d::Zero();
    m_new_rotation = Vec3d::Zero();
    m_new_absolute_rotation = Vec3d::Zero();
    m_new_scale = Vec3d::Ones() * 100.;
    m_new_size = Vec3d::Zero();
    m_new_enabled = false;
    // no need to set the dirty flag here as this method is called from update_settings_value(),
    // which is called from update_if_dirty(), which resets the dirty flag anyways.
//    m_dirty = true;
}

References m_new_absolute_rotation, m_new_enabled, m_new_position, m_new_rotation, m_new_scale, and m_new_size.

Referenced by update_settings_value().

Here is the caller graph for this function:

reset_zero_button()

bool Slic3r::GUI::GizmoObjectManipulation::reset_zero_button	(	ImGuiWrapper *	imgui_wrapper,
		bool	enabled )

{
    imgui_wrapper->disabled_begin(!enabled);
    bool        pressed   = false;
    ImTextureID normal_id = m_glcanvas.get_gizmos_manager().get_icon_texture_id(GLGizmosManager::MENU_ICON_NAME::IC_TOOLBAR_RESET_ZERO);
    ImTextureID hover_id  = m_glcanvas.get_gizmos_manager().get_icon_texture_id(GLGizmosManager::MENU_ICON_NAME::IC_TOOLBAR_RESET_ZERO_HOVER);
 
    float  scale       = m_glcanvas.get_scale();
    #ifdef WIN32
        int dpi = get_dpi_for_window(wxGetApp().GetTopWindow());
        scale *= (float) dpi / (float) DPI_DEFAULT;
    #endif // WIN32
    ImVec2 button_size = ImVec2(16 * scale, 16 * scale); // ORCA: Use exact resolution will prevent blur on icon
 
    ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 0.0f);
 
    pressed = ImGui::ImageButton3(normal_id, hover_id, button_size, {0,0}, {1,1}, -1, {0,0,0,0}, {1,1,1, enabled ? 1.f : 0.f});  // ORCA make icon invisible to prevent changes on layout
 
    ImGui::PopStyleVar(1);
 
    imgui_wrapper->disabled_end();
    return pressed;
}

References Slic3r::GUI::ImGuiWrapper::disabled_begin(), Slic3r::GUI::ImGuiWrapper::disabled_end(), Slic3r::GUI::DPI_DEFAULT, Slic3r::GUI::get_dpi_for_window(), Slic3r::GUI::GLGizmosManager::IC_TOOLBAR_RESET_ZERO, Slic3r::GUI::GLGizmosManager::IC_TOOLBAR_RESET_ZERO_HOVER, m_glcanvas, and scale().

Referenced by do_render_rotate_window().

Here is the call graph for this function:

Here is the caller graph for this function:

set_coordinates_type()

void Slic3r::GUI::GizmoObjectManipulation::set_coordinates_type

(

ECoordinatesType

type

)

{
    /*if (wxGetApp().get_mode() == comSimple)
        type = ECoordinatesType::World;*/
 
    if (m_coordinates_type == type) return;
 
    m_coordinates_type = type;
    //m_word_local_combo->SetSelection((int) m_coordinates_type);
    this->UpdateAndShow(true);
    GLCanvas3D *canvas = wxGetApp().plater()->canvas3D();
    canvas->get_gizmos_manager().update_data();
    canvas->set_as_dirty();
    canvas->request_extra_frame();
 
}

References Slic3r::GUI::GLCanvas3D::get_gizmos_manager(), m_coordinates_type, Slic3r::GUI::GLCanvas3D::request_extra_frame(), Slic3r::GUI::GLCanvas3D::set_as_dirty(), Slic3r::GUI::GLGizmosManager::update_data(), and UpdateAndShow().

Referenced by do_render_move_window(), and do_render_scale_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

set_dirty()

void Slic3r::GUI::GizmoObjectManipulation::set_dirty ( )

inline

{ m_dirty = true; }

References m_dirty.

Referenced by set_uniform_scaling(), and UpdateAndShow().

Here is the caller graph for this function:

set_init_rotation()

void Slic3r::GUI::GizmoObjectManipulation::set_init_rotation

(

const Geometry::Transformation &

value

)

                                                                                   {
    m_init_rotation_scale_tran = value.get_matrix_no_offset();
    m_init_rotation      = value.get_rotation();
}

References Slic3r::Geometry::Transformation::get_matrix_no_offset(), Slic3r::Geometry::Transformation::get_rotation(), m_init_rotation, and m_init_rotation_scale_tran.

Here is the call graph for this function:

set_uniform_scaling()

void Slic3r::GUI::GizmoObjectManipulation::set_uniform_scaling

(

const bool

uniform_scale

)

{
    if (!use_uniform_scale)
        // Recalculate cached values at this panel, refresh the screen.
        this->UpdateAndShow(true);
 
    m_uniform_scale = use_uniform_scale;
    set_dirty();
}

References m_uniform_scale, set_dirty(), and UpdateAndShow().

Referenced by do_render_scale_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

set_use_object_cs()

void Slic3r::GUI::GizmoObjectManipulation::set_use_object_cs ( bool flag )

inline

{ if (m_use_object_cs != flag) m_use_object_cs = flag; }

References m_use_object_cs.

update_buffered_value()

void Slic3r::GUI::GizmoObjectManipulation::update_buffered_value ( )

private

{
    if (this->m_imperial_units)
        m_buffered_position = this->m_new_position * this->mm_to_in;
    else
        m_buffered_position = this->m_new_position;
 
    m_buffered_rotation = this->m_new_rotation;
    m_buffered_absolute_rotation = this->m_new_absolute_rotation;
    m_buffered_scale = this->m_new_scale;
 
    if (this->m_imperial_units)
        m_buffered_size = this->m_new_size * this->mm_to_in;
    else
        m_buffered_size = this->m_new_size;
}

References m_buffered_absolute_rotation, m_buffered_position, m_buffered_rotation, m_buffered_scale, m_buffered_size, m_imperial_units, m_new_absolute_rotation, m_new_position, m_new_rotation, m_new_scale, m_new_size, and mm_to_in.

Referenced by update_if_dirty(), and update_ui_from_settings().

Here is the caller graph for this function:

update_if_dirty()

void Slic3r::GUI::GizmoObjectManipulation::update_if_dirty

(

)

{
    if (! m_dirty)
        return;
 
    const Selection &selection = m_glcanvas.get_selection();
    this->update_settings_value(selection);
    this->update_buffered_value();
 
    auto update_label = [](wxString &label_cache, const std::string &new_label) {
        wxString new_label_localized = _(new_label) + ":";
        if (label_cache != new_label_localized) {
            label_cache = new_label_localized;
        }
    };
    update_label(m_cache.move_label_string,   m_new_move_label_string);
    update_label(m_cache.rotate_label_string, m_new_rotate_label_string);
    update_label(m_cache.rotate_label_string, m_new_rotate_label_string);
    update_label(m_cache.scale_label_string,  m_new_scale_label_string);
 
    enum ManipulationEditorKey
    {
        mePosition = 0,
        meRotation,
        meScale,
        meSize
    };
 
    for (int i = 0; i < 3; ++ i) {
        auto update = [i](Vec3d &cached, Vec3d &cached_rounded,  const Vec3d &new_value) {
      //wxString new_text = double_to_string(new_value(i), 2);
      double new_rounded = round(new_value(i)*100)/100.0;
      //new_text.ToDouble(&new_rounded);
      if (std::abs(cached_rounded(i) - new_rounded) > EPSILON) {
        cached_rounded(i) = new_rounded;
                //const int id = key_id*3+i;
                //if (m_imperial_units && (key_id == mePosition || key_id == meSize))
                //    new_text = double_to_string(new_value(i)*mm_to_in, 2);
                //if (id >= 0) m_editors[id]->set_value(new_text);
            }
      cached(i) = new_value(i);
    };
        update(m_cache.position, m_cache.position_rounded,  m_new_position);
        update(m_cache.scale,    m_cache.scale_rounded,     m_new_scale);
        update(m_cache.size,     m_cache.size_rounded,      m_new_size);
        update(m_cache.rotation, m_cache.rotation_rounded,  m_new_rotation);
        update(m_cache.absolute_rotation, m_cache.absolute_rotation_rounded, m_new_absolute_rotation);
    }
 
    update_reset_buttons_visibility();
    //update_mirror_buttons_visibility();
 
    m_dirty = false;
}

References _, EPSILON, m_cache, m_dirty, m_glcanvas, m_new_absolute_rotation, m_new_move_label_string, m_new_position, m_new_rotate_label_string, m_new_rotation, m_new_scale, m_new_scale_label_string, m_new_size, update_buffered_value(), update_reset_buttons_visibility(), and update_settings_value().

Referenced by UpdateAndShow().

Here is the call graph for this function:

Here is the caller graph for this function:

update_reset_buttons_visibility()

void Slic3r::GUI::GizmoObjectManipulation::update_reset_buttons_visibility ( )

private

{
    const Selection& selection = m_glcanvas.get_selection();
 
    // Assembly view has its own selection and transformations, which drop_selection() doesn't update
    m_enable_drop_to_bed = m_glcanvas.get_canvas_type() == GLCanvas3D::ECanvasType::CanvasView3D && selection.can_drop();
 
    if (selection.is_single_full_instance() || selection.is_single_volume_or_modifier()) {
        const GLVolume *               volume = selection.get_first_volume();
 
        Vec3d rotation;
        Vec3d scale;
 
        if (selection.is_single_full_instance()) {
            rotation = volume->get_instance_rotation();
            scale = volume->get_instance_scaling_factor();
        }
        else {
            rotation = volume->get_volume_rotation();
            scale = volume->get_volume_scaling_factor();
        }
        m_show_clear_rotation = !rotation.isApprox(m_init_rotation);
        m_show_reset_0_rotation = !rotation.isApprox(Vec3d::Zero());
        m_show_clear_scale = (m_cache.scale / 100.0f - Vec3d::Ones()).norm() > 0.001;
    }
}

References Slic3r::GUI::Selection::can_drop(), Slic3r::GUI::GLCanvas3D::CanvasView3D, Slic3r::GUI::Selection::get_first_volume(), Slic3r::GLVolume::get_instance_rotation(), Slic3r::GLVolume::get_instance_scaling_factor(), Slic3r::GLVolume::get_volume_rotation(), Slic3r::GLVolume::get_volume_scaling_factor(), Slic3r::GUI::Selection::is_single_full_instance(), Slic3r::GUI::Selection::is_single_volume_or_modifier(), m_cache, m_enable_drop_to_bed, m_glcanvas, m_init_rotation, m_show_clear_rotation, m_show_clear_scale, m_show_reset_0_rotation, and scale().

Referenced by update_if_dirty().

Here is the call graph for this function:

Here is the caller graph for this function:

update_settings_value()

void Slic3r::GUI::GizmoObjectManipulation::update_settings_value ( const Selection & selection )

private

{
  m_new_move_label_string   = L("Position");
    m_new_rotate_label_string = L("Rotate (relative)");
    m_new_rotation            = Vec3d::Zero();
    m_new_absolute_rotation   = Vec3d::Zero();
    m_new_scale_label_string  = L("Scale ratios");
 
    ObjectList* obj_list = wxGetApp().obj_list();
    if (selection.is_single_full_instance()) {
        // all volumes in the selection belongs to the same instance, any of them contains the needed instance data, so we take the first one
        const GLVolume* volume = selection.get_first_volume();
        m_new_position = volume->get_instance_offset();
        auto rotation = volume->get_instance_transformation().get_rotation_by_quaternion();
        m_new_absolute_rotation = rotation * (180. / M_PI);
        delete_negative_sign(m_new_absolute_rotation);
        if (is_world_coordinates()) {//for move and rotate
            m_new_size     = selection.get_bounding_box_in_current_reference_system().first.size();
            m_unscale_size = selection.get_unscaled_instance_bounding_box().size();
            m_new_scale    = m_new_size.cwiseQuotient(m_unscale_size) * 100.0;
    }
        else {//if (is_local_coordinates()) {//for scale
            auto tran      = selection.get_first_volume()->get_instance_transformation();
            m_new_position = tran.get_matrix().inverse() * cs_center;
            if (is_instance_coordinates()) {
                m_new_position = Vec3d::Zero();
            }
            m_new_size  = selection.get_bounding_box_in_current_reference_system().first.size();
            m_unscale_size = selection.get_full_unscaled_instance_local_bounding_box().size();
            m_new_scale    = m_new_size.cwiseQuotient(m_unscale_size) * 100.0;
    }
 
        m_new_enabled  = true;
        // BBS: change "Instance Operations" to "Object Operations"
        m_new_title_string = L("Object operations");
    }
    else if (selection.is_single_full_object() && obj_list->is_selected(itObject)) {
        const BoundingBoxf3& box = selection.get_bounding_box();
        m_new_position = box.center();
        m_new_scale    = Vec3d(100., 100., 100.);
        m_new_size     = selection.get_bounding_box_in_current_reference_system().first.size();
    m_new_scale_label_string  = L("Scale");
        m_new_enabled  = true;
        m_new_title_string = L("Object operations");
    } else if (selection.is_single_volume_or_modifier()) {
        const GLVolume *volume = selection.get_first_volume();
        auto            rotation = volume->get_volume_transformation().get_rotation_by_quaternion();
        m_new_absolute_rotation  = rotation * (180. / M_PI);
        delete_negative_sign(m_new_absolute_rotation);
        if (is_world_coordinates()) {//for move and rotate
            const Geometry::Transformation trafo(volume->world_matrix());
            const Vec3d &offset = trafo.get_offset();
            m_new_position            = offset;
            m_new_scale               = Vec3d(100.0, 100.0, 100.0);
            m_unscale_size            = selection.get_bounding_box_in_current_reference_system().first.size();
            m_new_size                = selection.get_bounding_box_in_current_reference_system().first.size();
        } else if (is_local_coordinates()) {//for scale
            m_new_position            = Vec3d::Zero();
            m_new_scale               = volume->get_volume_scaling_factor() * 100.0;
            m_unscale_size            = selection.get_bounding_box_in_current_reference_system().first.size();
            m_new_size                = selection.get_bounding_box_in_current_reference_system().first.size();
        } else {
            m_new_position            = volume->get_volume_offset();
            m_new_scale_label_string  = L("Scale");
            m_new_scale               = Vec3d(100.0, 100.0, 100.0);
            m_unscale_size            = selection.get_bounding_box_in_current_reference_system().first.size();
            m_new_size                = selection.get_bounding_box_in_current_reference_system().first.size();
        }
        m_new_enabled = true;
        m_new_title_string = L("Volume operations");
    } else if (obj_list->is_connectors_item_selected() || obj_list->multiple_selection() || obj_list->is_selected(itInstanceRoot)) {
        reset_settings_value();
    m_new_move_label_string   = L("Translate");
    m_new_scale_label_string  = L("Scale");
        m_unscale_size            = selection.get_bounding_box_in_current_reference_system().first.size();
        m_new_size                = selection.get_bounding_box_in_current_reference_system().first.size();
        m_new_enabled  = true;
        m_new_title_string = L("Group operations");
    } else if (selection.is_wipe_tower()) {
        const BoundingBoxf3 &box = selection.get_bounding_box();
        m_new_position           = box.center();
    }
  else {
        // No selection, reset the cache.
//    assert(selection.is_empty());
    reset_settings_value();
  }
}

References Slic3r::BoundingBox3Base< PointType >::center(), cs_center, Slic3r::GUI::delete_negative_sign(), Slic3r::GUI::Selection::get_bounding_box(), Slic3r::GUI::Selection::get_bounding_box_in_current_reference_system(), Slic3r::GUI::Selection::get_first_volume(), Slic3r::GUI::Selection::get_full_unscaled_instance_local_bounding_box(), Slic3r::GLVolume::get_instance_offset(), Slic3r::GLVolume::get_instance_transformation(), Slic3r::Geometry::Transformation::get_offset(), Slic3r::Geometry::Transformation::get_rotation_by_quaternion(), Slic3r::GUI::Selection::get_unscaled_instance_bounding_box(), Slic3r::GLVolume::get_volume_offset(), Slic3r::GLVolume::get_volume_scaling_factor(), Slic3r::GLVolume::get_volume_transformation(), is_instance_coordinates(), is_local_coordinates(), Slic3r::GUI::Selection::is_single_full_instance(), Slic3r::GUI::Selection::is_single_full_object(), Slic3r::GUI::Selection::is_single_volume_or_modifier(), Slic3r::GUI::Selection::is_wipe_tower(), is_world_coordinates(), Slic3r::GUI::itInstanceRoot, Slic3r::GUI::itObject, L, m_new_absolute_rotation, m_new_enabled, m_new_move_label_string, m_new_position, m_new_rotate_label_string, m_new_rotation, m_new_scale, m_new_scale_label_string, m_new_size, m_new_title_string, M_PI, m_unscale_size, Slic3r::GUI::obj_list(), Slic3r::offset(), reset_settings_value(), Slic3r::BoundingBox3Base< PointType >::size(), and Slic3r::GLVolume::world_matrix().

Referenced by update_if_dirty().

Here is the call graph for this function:

Here is the caller graph for this function:

update_ui_from_settings()

void Slic3r::GUI::GizmoObjectManipulation::update_ui_from_settings

(

)

{
    if (m_imperial_units != (wxGetApp().app_config->get("use_inches") == "1")) {
        m_imperial_units = wxGetApp().app_config->get("use_inches") == "1";
 
        m_new_unit_string = m_imperial_units ? L_CONTEXT("in", "inches") : L("mm");
 
        update_buffered_value();
    }
}

References L, L_CONTEXT, m_imperial_units, m_new_unit_string, and update_buffered_value().

Here is the call graph for this function:

UpdateAndShow()

void Slic3r::GUI::GizmoObjectManipulation::UpdateAndShow

(

const bool

show

)

{
  if (show) {
        this->set_dirty();
    this->update_if_dirty();
  }
}

References set_dirty(), and update_if_dirty().

Referenced by change_absolute_rotation_value(), change_position_value(), change_rotation_value(), change_scale_value(), change_size_value(), do_render_move_window(), do_render_scale_input_window(), reset_position_value(), reset_rotation_value(), set_coordinates_type(), and set_uniform_scaling().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

cs_center

Vec3d Slic3r::GUI::GizmoObjectManipulation::cs_center

Referenced by update_settings_value().

g_to_oz

const double Slic3r::GUI::GizmoObjectManipulation::g_to_oz = 0.035274

static

in_to_mm

const double Slic3r::GUI::GizmoObjectManipulation::in_to_mm = 25.4

static

Referenced by Slic3r::GUI::GLGizmoEmboss::draw_advanced(), Slic3r::GUI::GLGizmoSVG::draw_depth(), Slic3r::GUI::GLGizmoSVG::draw_distance(), Slic3r::GUI::Emboss::StyleManager::init_style_images(), on_change(), Slic3r::GUI::GCodeViewer::render_all_plates_stats(), Slic3r::GUI::GLGizmoCut3D::render_double_input(), Slic3r::GUI::GLGizmoCut3D::render_move_center_input(), Slic3r::GUI::GLGizmoCut3D::render_slider_input(), Slic3r::GUI::GLGizmoCut3D::render_slider_two_input(), and Slic3r::GUI::GLGizmoEmboss::rev_input_mm().

last_move_input_window_width

float Slic3r::GUI::GizmoObjectManipulation::last_move_input_window_width = 0.0f

protected

Referenced by do_render_move_window().

last_rotate_input_window_width

float Slic3r::GUI::GizmoObjectManipulation::last_rotate_input_window_width = 0.0f

protected

Referenced by do_render_rotate_window().

last_scale_input_window_width

float Slic3r::GUI::GizmoObjectManipulation::last_scale_input_window_width = 0.0f

protected

Referenced by do_render_scale_input_window().

m_align_to_parent

bool Slic3r::GUI::GizmoObjectManipulation::m_align_to_parent {false}

private

{false};

Referenced by do_render_move_window(), get_align_to_parent(), and reset_align_state().

m_alignment_helper

GLGizmoAlignment Slic3r::GUI::GizmoObjectManipulation::m_alignment_helper

private

Referenced by GizmoObjectManipulation(), do_render_move_window(), get_alignment_helper(), and reset_align_state().

m_buffered_absolute_rotation

Vec3d Slic3r::GUI::GizmoObjectManipulation::m_buffered_absolute_rotation

Referenced by do_render_rotate_window(), and update_buffered_value().

m_buffered_position

Vec3d Slic3r::GUI::GizmoObjectManipulation::m_buffered_position

Referenced by do_render_move_window(), do_render_rotate_window(), do_render_scale_input_window(), and update_buffered_value().

m_buffered_rotation

Vec3d Slic3r::GUI::GizmoObjectManipulation::m_buffered_rotation

Referenced by do_render_rotate_window(), and update_buffered_value().

m_buffered_scale

Vec3d Slic3r::GUI::GizmoObjectManipulation::m_buffered_scale

Referenced by do_render_scale_input_window(), and update_buffered_value().

m_buffered_size

Vec3d Slic3r::GUI::GizmoObjectManipulation::m_buffered_size

Referenced by do_render_scale_input_window(), and update_buffered_value().

m_cache

Cache Slic3r::GUI::GizmoObjectManipulation::m_cache

Referenced by change_absolute_rotation_value(), change_position_value(), change_rotation_value(), change_scale_value(), change_size_value(), get_cache(), on_change(), reset_cache(), update_if_dirty(), and update_reset_buttons_visibility().

m_can_align_within

bool Slic3r::GUI::GizmoObjectManipulation::m_can_align_within {false}

private

{false};

Referenced by do_render_move_window(), and reset_align_state().

m_coordinates_type

ECoordinatesType Slic3r::GUI::GizmoObjectManipulation::m_coordinates_type {ECoordinatesType::World}

{ECoordinatesType::World};

Referenced by change_position_value(), do_render_move_window(), do_render_scale_input_window(), get_coordinates_type(), is_instance_coordinates(), is_local_coordinates(), is_world_coordinates(), and set_coordinates_type().

m_dirty

bool Slic3r::GUI::GizmoObjectManipulation::m_dirty = false

Referenced by set_dirty(), and update_if_dirty().

m_enable_drop_to_bed

bool Slic3r::GUI::GizmoObjectManipulation::m_enable_drop_to_bed { false }

{ false };

Referenced by do_render_move_window(), and update_reset_buttons_visibility().

m_glcanvas

GLCanvas3D& Slic3r::GUI::GizmoObjectManipulation::m_glcanvas

private

Referenced by GizmoObjectManipulation(), change_absolute_rotation_value(), change_position_value(), change_rotation_value(), change_scale_value(), change_size_value(), do_render_move_window(), do_render_rotate_window(), do_render_scale_input_window(), do_scale(), reset_button(), reset_position_value(), reset_rotation_value(), reset_zero_button(), update_if_dirty(), and update_reset_buttons_visibility().

m_hovered_align_type

GLGizmoAlignment::AlignType Slic3r::GUI::GizmoObjectManipulation::m_hovered_align_type {GLGizmoAlignment::AlignType::NONE}

private

{GLGizmoAlignment::AlignType::NONE};

Referenced by do_render_move_window(), get_hovered_align_type(), and reset_align_state().

m_imperial_units

bool Slic3r::GUI::GizmoObjectManipulation::m_imperial_units { false }

{ false };

Referenced by GizmoObjectManipulation(), do_render_move_window(), do_render_rotate_window(), do_render_scale_input_window(), on_change(), update_buffered_value(), and update_ui_from_settings().

m_init_rotation

Vec3d Slic3r::GUI::GizmoObjectManipulation::m_init_rotation

private

Referenced by set_init_rotation(), and update_reset_buttons_visibility().

m_init_rotation_scale_tran

Transform3d Slic3r::GUI::GizmoObjectManipulation::m_init_rotation_scale_tran

private

Referenced by reset_rotation_value(), and set_init_rotation().

m_last_active_item

unsigned int Slic3r::GUI::GizmoObjectManipulation::m_last_active_item { 0 }

private

{ 0 };

Referenced by do_render_move_window(), do_render_rotate_window(), and do_render_scale_input_window().

m_last_rotate_type

RotateType Slic3r::GUI::GizmoObjectManipulation::m_last_rotate_type {RotateType::None}

{RotateType::None}; // 0:no input 1:relative 2:absolute

Referenced by do_render_rotate_window().

m_new_absolute_rotation

Vec3d Slic3r::GUI::GizmoObjectManipulation::m_new_absolute_rotation

Referenced by do_render_rotate_window(), reset_settings_value(), update_buffered_value(), update_if_dirty(), and update_settings_value().

m_new_enabled

bool Slic3r::GUI::GizmoObjectManipulation::m_new_enabled {true}

{true};

Referenced by reset_settings_value(), and update_settings_value().

m_new_move_label_string

std::string Slic3r::GUI::GizmoObjectManipulation::m_new_move_label_string

Referenced by update_if_dirty(), and update_settings_value().

m_new_position

Vec3d Slic3r::GUI::GizmoObjectManipulation::m_new_position

Referenced by do_render_move_window(), do_render_rotate_window(), reset_settings_value(), update_buffered_value(), update_if_dirty(), and update_settings_value().

m_new_rotate_label_string

std::string Slic3r::GUI::GizmoObjectManipulation::m_new_rotate_label_string

Referenced by update_if_dirty(), and update_settings_value().

m_new_rotation

Vec3d Slic3r::GUI::GizmoObjectManipulation::m_new_rotation

Referenced by do_render_rotate_window(), reset_settings_value(), update_buffered_value(), update_if_dirty(), and update_settings_value().

m_new_scale

Vec3d Slic3r::GUI::GizmoObjectManipulation::m_new_scale

Referenced by do_render_scale_input_window(), reset_settings_value(), update_buffered_value(), update_if_dirty(), and update_settings_value().

m_new_scale_label_string

std::string Slic3r::GUI::GizmoObjectManipulation::m_new_scale_label_string

Referenced by update_if_dirty(), and update_settings_value().

m_new_size

Vec3d Slic3r::GUI::GizmoObjectManipulation::m_new_size

Referenced by do_render_scale_input_window(), reset_settings_value(), update_buffered_value(), update_if_dirty(), and update_settings_value().

m_new_title_string

std::string Slic3r::GUI::GizmoObjectManipulation::m_new_title_string

Referenced by do_render_move_window(), do_render_rotate_window(), do_render_scale_input_window(), and update_settings_value().

m_new_unit_string

std::string Slic3r::GUI::GizmoObjectManipulation::m_new_unit_string

Referenced by GizmoObjectManipulation(), do_render_move_window(), do_render_scale_input_window(), and update_ui_from_settings().

m_shortcuts_move

std::vector<std::pair<wxString, wxString> > Slic3r::GUI::GizmoObjectManipulation::m_shortcuts_move

private

Referenced by GizmoObjectManipulation(), and do_render_move_window().

m_shortcuts_rotate

std::vector<std::pair<wxString, wxString> > Slic3r::GUI::GizmoObjectManipulation::m_shortcuts_rotate

private

Referenced by GizmoObjectManipulation(), and do_render_rotate_window().

m_shortcuts_scale

std::vector<std::pair<wxString, wxString> > Slic3r::GUI::GizmoObjectManipulation::m_shortcuts_scale

private

Referenced by GizmoObjectManipulation(), and do_render_scale_input_window().

m_show_clear_rotation

bool Slic3r::GUI::GizmoObjectManipulation::m_show_clear_rotation { false }

{ false };

Referenced by do_render_rotate_window(), and update_reset_buttons_visibility().

m_show_clear_scale

bool Slic3r::GUI::GizmoObjectManipulation::m_show_clear_scale { false }

{ false };

Referenced by change_scale_value(), do_render_scale_input_window(), and update_reset_buttons_visibility().

m_show_reset_0_rotation

bool Slic3r::GUI::GizmoObjectManipulation::m_show_reset_0_rotation {false}

{false};

Referenced by do_render_rotate_window(), and update_reset_buttons_visibility().

m_uniform_scale

bool Slic3r::GUI::GizmoObjectManipulation::m_uniform_scale {true}

{true};

Referenced by do_render_scale_input_window(), do_scale(), get_uniform_scaling(), and set_uniform_scaling().

m_unscale_size

Vec3d Slic3r::GUI::GizmoObjectManipulation::m_unscale_size

Referenced by limit_scaling_ratio(), and update_settings_value().

m_use_object_cs

bool Slic3r::GUI::GizmoObjectManipulation::m_use_object_cs {false}

{false};

Referenced by get_use_object_cs(), and set_use_object_cs().

mm_to_in

const double Slic3r::GUI::GizmoObjectManipulation::mm_to_in = 0.0393700787

static

Referenced by do_render_move_window(), do_render_rotate_window(), do_render_scale_input_window(), Slic3r::GUI::GLGizmoEmboss::draw_advanced(), Slic3r::GUI::GLGizmoSVG::draw_depth(), Slic3r::GUI::GLGizmoSVG::draw_distance(), Slic3r::GUI::GLGizmoSVG::draw_size(), Slic3r::GUI::GLGizmoCut3D::get_tooltip(), Slic3r::GUI::GLGizmoCut3D::render_build_size(), Slic3r::GUI::GLGizmoMeasure::render_dimensioning(), Slic3r::GUI::GLGizmoCut3D::render_double_input(), Slic3r::GUI::GLGizmoCut3D::render_move_center_input(), Slic3r::GUI::GLGizmoCut3D::render_slider_input(), Slic3r::GUI::GLGizmoCut3D::render_slider_two_input(), Slic3r::GUI::GLGizmoEmboss::rev_input_mm(), Slic3r::GUI::GLGizmoMeasure::show_distance_xyz_ui(), Slic3r::GUI::Plater::show_object_info(), Slic3r::GUI::GLGizmoMeasure::show_selection_ui(), update_buffered_value(), and Slic3r::GUI::GLGizmoMeasure::update_measurement_result().

oz_to_g

const double Slic3r::GUI::GizmoObjectManipulation::oz_to_g = 28.34952

static

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

---

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

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