Slic3r::GUI::GLGizmoSVG Class Reference

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

Inheritance diagram for Slic3r::GUI::GLGizmoSVG:

Collaboration diagram for Slic3r::GUI::GLGizmoSVG:

Classes
struct	GuiCfg

Public Types
enum class	EGrabberExtension {   None = 0 , PosX = 1 << 0 , NegX = 1 << 1 , PosY = 1 << 2 ,   NegY = 1 << 3 , PosZ = 1 << 4 , NegZ = 1 << 5 }
enum	EState { Off , On , Num_States }

Public Member Functions
	GLGizmoSVG (GLCanvas3D &parent)
bool	create_volume (ModelVolumeType volume_type, const Vec2d &mouse_pos)
	Create new embossed text volume by type on position of mouse.
bool	create_volume (ModelVolumeType volume_type)
	Create new text without given position.
bool	create_volume (std::string_view svg_file, const Vec2d &mouse_pos, ModelVolumeType volume_type=ModelVolumeType::MODEL_PART)
	Create volume from already selected svg file.
bool	create_volume (std::string_view svg_file, ModelVolumeType volume_type=ModelVolumeType::MODEL_PART)
bool	init ()
void	load (cereal::BinaryInputArchive &ar)
void	save (cereal::BinaryOutputArchive &ar) const
std::string	get_name (bool include_shortcut=true) const
EState	get_state () const
void	set_state (EState state)
std::optional< Shortcut >	shortcut () const
const std::string &	get_icon_filename () const
void	set_icon_filename (const std::string &filename)
bool	is_activable () const
bool	is_selectable () const
CommonGizmosDataID	get_requirements () const
virtual bool	render_follows_cursor () const
void	set_common_data_pool (CommonGizmosDataPool *ptr)
virtual bool	apply_clipping_plane ()
unsigned int	get_sprite_id () const
int	get_hover_id () const
void	set_hover_id (int id)
bool	is_dragging () const
bool	update_items_state ()
void	render ()
void	render_input_window (float x, float y, float bottom_limit)
virtual void	on_change_color_mode (bool is_dark)
virtual std::string	get_tooltip () const
	Mouse tooltip text.
int	get_count ()
std::string	get_gizmo_name ()
void	register_raycasters_for_picking ()
void	unregister_raycasters_for_picking ()
virtual bool	is_in_editing_mode () const
virtual bool	is_selection_rectangle_dragging () const

Static Public Member Functions
static bool	is_svg_object (const ModelVolume &volume)
	Check whether volume is object containing only emboss volume.
static bool	is_svg (const ModelVolume &volume)
	Check whether volume has emboss data.
static void	update_render_colors ()
static void	load_render_colors ()

Static Public Attributes
static const unsigned int	BASE_ID = 255 * 255 * 254
static const unsigned int	GRABBER_ELEMENTS_MAX_COUNT = 7
static float	INV_ZOOM = 1.0f
static ColorRGBA	DEFAULT_BASE_COLOR = { 0.625f, 0.625f, 0.625f, 1.0f }
static ColorRGBA	DEFAULT_DRAG_COLOR = { 1.0f, 1.0f, 1.0f, 1.0f }
static ColorRGBA	DEFAULT_HIGHLIGHT_COLOR = {1.0f, 0.38f, 0.0f, 1.0f}
static std::array< ColorRGBA, 3 >	AXES_COLOR
static std::array< ColorRGBA, 3 >	AXES_HOVER_COLOR
static ColorRGBA	CONSTRAINED_COLOR = {0.5f, 0.5f, 0.5f, 1.0f}
static ColorRGBA	FLATTEN_COLOR = {0.96f, 0.93f, 0.93f, 0.5f}
static ColorRGBA	FLATTEN_HOVER_COLOR = {1.0f, 1.0f, 1.0f, 0.75f}
static ColorRGBA	GRABBER_NORMAL_COL = {1.0f, 1.0f, 1.0f, 1.0f}
static ColorRGBA	GRABBER_HOVER_COL = {0.863f, 0.125f, 0.063f, 1.0f}
static ColorRGBA	GRABBER_UNIFORM_COL = {0, 1.0, 1.0, 1.0f}
static ColorRGBA	GRABBER_UNIFORM_HOVER_COL = {0, 0.7, 0.7, 1.0f}

Protected Member Functions
bool	on_init () override
std::string	on_get_name () const override
void	on_render () override
void	on_register_raycasters_for_picking () override
void	on_unregister_raycasters_for_picking () override
void	on_render_input_window (float x, float y, float bottom_limit) override
bool	on_is_activable () const override
bool	on_is_selectable () const override
void	on_set_state () override
void	data_changed (bool is_serializing) override
	Is called when data (Selection) is changed.
void	on_set_hover_id () override
void	on_enable_grabber (unsigned int id) override
void	on_disable_grabber (unsigned int id) override
void	on_start_dragging () override
void	on_stop_dragging () override
void	on_dragging (const UpdateData &data) override
bool	on_mouse (const wxMouseEvent &mouse_event) override
	Rotate by text on dragging rotate grabers.
bool	wants_enter_leave_snapshots () const override
std::string	get_gizmo_entering_text () const override
std::string	get_gizmo_leaving_text () const override
std::string	get_action_snapshot_name () const override
bool	render_combo (const std::string &label, const std::vector< std::string > &lines, int &selection_idx, float label_width, float item_width)
void	render_cross_mark (const Vec3f &target, bool is_single=false)
virtual void	on_load (cereal::BinaryInputArchive &ar)
virtual void	on_save (cereal::BinaryOutputArchive &ar) const
virtual CommonGizmosDataID	on_get_requirements () const
bool	GizmoImguiBegin (const std::string &name, int flags)
void	GizmoImguiEnd ()
void	GizmoImguiSetNextWIndowPos (float &x, float y, int flag, float pivot_x=0.0f, float pivot_y=0.0f)
void	GizmoImguiSetNextWIndowPos (float &x, float y, float w, float h, int flag, float pivot_x=0.0f, float pivot_y=0.0f)
void	register_grabbers_for_picking ()
void	unregister_grabbers_for_picking ()
void	render_grabbers (const BoundingBoxf3 &box) const
void	render_grabbers (float size) const
void	render_grabbers (size_t first, size_t last, float size, bool force_hover) const
std::string	format (float value, unsigned int decimals) const
void	set_dirty ()
bool	use_grabbers (const wxMouseEvent &mouse_event)
	function which Set up m_dragging and call functions on_start_dragging / on_dragging / on_stop_dragging
void	do_stop_dragging (bool perform_mouse_cleanup)

Protected Attributes
GLCanvas3D &	m_parent
int	m_group_id
EState	m_state
std::optional< Shortcut >	m_shortcut
std::string	m_icon_filename
unsigned int	m_sprite_id
int	m_hover_id { -1 }
bool	m_dragging { false }
std::vector< Grabber >	m_grabbers
ImGuiWrapper *	m_imgui
bool	m_first_input_window_render { true }
CommonGizmosDataPool *	m_c { nullptr }
bool	m_is_dark_mode = false
float	last_input_window_width = 0

Private Member Functions
void	set_volume_by_selection ()
void	reset_volume ()
bool	process (bool make_snapshot=true)
void	close ()
void	draw_window ()
void	draw_preview ()
void	draw_filename ()
void	draw_depth ()
void	draw_size ()
void	draw_use_surface ()
void	draw_distance ()
void	draw_rotation ()
void	draw_mirroring ()
void	draw_face_the_camera ()
void	draw_model_type ()
bool	on_mouse_for_rotation (const wxMouseEvent &mouse_event)
bool	on_mouse_for_translate (const wxMouseEvent &mouse_event)
void	volume_transformation_changed ()
void	calculate_scale ()
float	get_scale_for_tolerance ()

Private Attributes
std::unique_ptr< const GuiCfg >	m_gui_cfg
ModelVolume *	m_volume = nullptr
EmbossShape	m_volume_shape
std::vector< std::string >	m_shape_warnings
ObjectID	m_volume_id
std::shared_ptr< std::atomic< bool > >	m_job_cancel = nullptr
GLGizmoRotate	m_rotate_gizmo
std::optional< float >	m_angle
std::optional< float >	m_distance
std::optional< float >	m_rotate_start_angle
RaycastManager	m_raycast_manager
bool	m_keep_up = true
bool	m_keep_ratio = true
std::optional< SurfaceDrag >	m_surface_drag
std::optional< float >	m_scale_width
std::optional< float >	m_scale_height
std::optional< float >	m_scale_depth
Texture	m_texture
BoundingBox	m_shape_bb
std::string	m_filename_preview
IconManager	m_icon_manager
IconManager::VIcons	m_icons
bool	m_dirty { false }
int	count = 0

Static Private Attributes
static const std::string	M_ICON_FILENAME = "cut.svg"

Detailed Description

Member Enumeration Documentation

EGrabberExtension

enum class Slic3r::GUI::GLGizmoBase::EGrabberExtension

stronginherited

Enumerator
None
PosX
NegX
PosY
NegY
PosZ
NegZ

    {
        None = 0,
        PosX = 1 << 0,
        NegX = 1 << 1,
        PosY = 1 << 2,
        NegY = 1 << 3,
        PosZ = 1 << 4,
        NegZ = 1 << 5,
    };

EState

enum Slic3r::GUI::GLGizmoBase::EState

inherited

Enumerator
Off
On
Num_States

    {
        Off,
        On,
        Num_States
    };

Constructor & Destructor Documentation

GLGizmoSVG()

GLGizmoSVG::GLGizmoSVG ( GLCanvas3D & parent )

explicit

    : GLGizmoBase(parent, M_ICON_FILENAME, -3)
    , m_gui_cfg(nullptr)
    , m_rotate_gizmo(parent, GLGizmoRotate::Axis::Z) // grab id = 2 (Z axis)
{
    m_rotate_gizmo.set_group_id(0);
    m_rotate_gizmo.set_force_local_coordinate(true);
}

References Slic3r::GUI::GLGizmoBase::GLGizmoBase(), m_gui_cfg, M_ICON_FILENAME, m_rotate_gizmo, and Slic3r::Z.

Here is the call graph for this function:

Member Function Documentation

apply_clipping_plane()

virtual bool Slic3r::GUI::GLGizmoBase::apply_clipping_plane ( )

inlinevirtualinherited

{ return true; }

Referenced by Slic3r::GUI::GLCanvas3D::_render_objects(), and Slic3r::GUI::GLCanvas3D::get_raycaster_clipping_plane().

Here is the caller graph for this function:

calculate_scale()

void GLGizmoSVG::calculate_scale ( )

private

                                 {
    // be carefull m_volume is not set yet
    const Selection &selection = m_parent.get_selection(); 
    const GLVolume *gl_volume = selection.get_first_volume();
    if (gl_volume == nullptr)
        return;
 
    Transform3d to_world = gl_volume->world_matrix();
 
    const ModelVolume *volume_ptr = get_model_volume(*gl_volume, selection.get_model()->objects);
    assert(volume_ptr != nullptr);
    assert(volume_ptr->emboss_shape.has_value());
    // Fix for volume loaded from 3mf
    if (volume_ptr != nullptr &&
        volume_ptr->emboss_shape.has_value()) {
        const std::optional<Transform3d> &fix_tr = volume_ptr->emboss_shape->fix_3mf_tr;
        if (fix_tr.has_value())
            to_world = to_world * (fix_tr->inverse());    
    }
    
    auto to_world_linear = to_world.linear();
    auto calc = [&to_world_linear](const Vec3d &axe, std::optional<float>& scale) {
        Vec3d axe_world = to_world_linear * axe;
        double norm_sq  = axe_world.squaredNorm();
        if (is_approx(norm_sq, 1.)) {
            if (!scale.has_value())
                return;
            scale.reset();
        } else {
            scale = sqrt(norm_sq);
        }
    };
 
    calc(Vec3d::UnitX(), m_scale_width);
    calc(Vec3d::UnitY(), m_scale_height);
    calc(Vec3d::UnitZ(), m_scale_depth);
}

References Slic3r::ModelVolume::emboss_shape, Slic3r::GUI::Selection::get_first_volume(), Slic3r::GUI::Selection::get_model(), Slic3r::GUI::get_model_volume(), Slic3r::is_approx(), Slic3r::GUI::GLGizmoBase::m_parent, m_scale_depth, m_scale_height, m_scale_width, Slic3r::Model::objects, scale(), and Slic3r::GLVolume::world_matrix().

Referenced by draw_size(), on_mouse_for_translate(), set_volume_by_selection(), and volume_transformation_changed().

Here is the call graph for this function:

Here is the caller graph for this function:

close()

void GLGizmoSVG::close ( )

private

{
    // close gizmo == open it again
    auto &mng = m_parent.get_gizmos_manager();
    if (mng.get_current_type() == GLGizmosManager::Svg)
        mng.open_gizmo(GLGizmosManager::Svg);
    reset_volume();
}

References Slic3r::GUI::GLGizmoBase::m_parent, reset_volume(), and Slic3r::GUI::GLGizmosManager::Svg.

Referenced by data_changed(), and draw_filename().

Here is the call graph for this function:

Here is the caller graph for this function:

create_volume() [1/4]

bool GLGizmoSVG::create_volume

(

ModelVolumeType

volume_type

)

Create new text without given position.

Parameters

volume_type

Object part / Negative volume / Modifier

Returns

True on succesfull start creation otherwise False

{
    CreateVolumeParams input = create_input(m_parent, m_raycast_manager, volume_type);
    DataBasePtr base = create_emboss_data_base(m_job_cancel,volume_type);
    if (!base) return false; // Uninterpretable svg
    return start_create_volume_without_position(input, std::move(base));
}

References m_job_cancel, Slic3r::GUI::GLGizmoBase::m_parent, m_raycast_manager, and Slic3r::GUI::Emboss::start_create_volume_without_position().

Here is the call graph for this function:

create_volume() [2/4]

bool GLGizmoSVG::create_volume	(	ModelVolumeType	volume_type,
		const Vec2d &	mouse_pos )

Create new embossed text volume by type on position of mouse.

Parameters

volume_type	Object part / Negative volume / Modifier
mouse_pos	Define position of new volume

Returns

True on succesfull start creation otherwise False

{
    CreateVolumeParams input = create_input(m_parent, m_raycast_manager, volume_type);
    DataBasePtr base = create_emboss_data_base(m_job_cancel, volume_type);
    if (!base) return false; // Uninterpretable svg
    return start_create_volume(input, std::move(base), mouse_pos);
}

References m_job_cancel, Slic3r::GUI::GLGizmoBase::m_parent, m_raycast_manager, and Slic3r::GUI::Emboss::start_create_volume().

Referenced by Slic3r::GUI::add_volume_with_gizmo(), and Slic3r::GUI::anonymous_namespace{Plater.cpp}::emboss_svg().

Here is the call graph for this function:

Here is the caller graph for this function:

create_volume() [3/4]

bool GLGizmoSVG::create_volume	(	std::string_view	svg_file,
		const Vec2d &	mouse_pos,
		ModelVolumeType	volume_type = ModelVolumeType::MODEL_PART )

Create volume from already selected svg file.

Parameters

svg_file	File path
mouse_pos	Position on screen where to create volume
volume_type	Object part / Negative volume / Modifier

Returns

True on succesfull start creation otherwise False

{
    CreateVolumeParams input = create_input(m_parent, m_raycast_manager, volume_type);
    DataBasePtr base = create_emboss_data_base(m_job_cancel, volume_type, svg_file);
    if (!base) return false; // Uninterpretable svg
    return start_create_volume(input, std::move(base), mouse_pos);
}

References m_job_cancel, Slic3r::GUI::GLGizmoBase::m_parent, m_raycast_manager, and Slic3r::GUI::Emboss::start_create_volume().

Here is the call graph for this function:

create_volume() [4/4]

bool GLGizmoSVG::create_volume	(	std::string_view	svg_file,
		ModelVolumeType	volume_type = ModelVolumeType::MODEL_PART )

                                                                                  {
    CreateVolumeParams input = create_input(m_parent, m_raycast_manager, volume_type);
    DataBasePtr base = create_emboss_data_base(m_job_cancel, volume_type, svg_file);
    if (!base) return false; // Uninterpretable svg
    return start_create_volume_without_position(input, std::move(base));
}

References m_job_cancel, Slic3r::GUI::GLGizmoBase::m_parent, m_raycast_manager, and Slic3r::GUI::Emboss::start_create_volume_without_position().

Here is the call graph for this function:

data_changed()

void GLGizmoSVG::data_changed ( bool is_serializing )

overrideprotectedvirtual

Is called when data (Selection) is changed.

Reimplemented from Slic3r::GUI::GLGizmoBase.

                                                 { 
    set_volume_by_selection();
    if (!is_serializing && m_volume == nullptr)
        close();
}

References close(), m_volume, and set_volume_by_selection().

Here is the call graph for this function:

do_stop_dragging()

void Slic3r::GUI::GLGizmoBase::do_stop_dragging ( bool perform_mouse_cleanup )

protectedinherited

{
    for (auto& grabber : m_grabbers) grabber.dragging = false;
    m_dragging = false;
 
    // NOTE: This should be part of GLCanvas3D
    // Reset hover_id when leave window
    if (perform_mouse_cleanup) m_parent.mouse_up_cleanup();
 
    on_stop_dragging();
 
    // There is prediction that after draggign, data are changed
    // Data are updated twice also by canvas3D::reload_scene.
    // Should be fixed.
    m_parent.get_gizmos_manager().update_data();
 
    wxGetApp().obj_manipul()->set_dirty();
 
    // Let the plater know that the dragging finished, so a delayed
    // refresh of the scene with the background processing data should
    // be performed.
    m_parent.post_event(SimpleEvent(EVT_GLCANVAS_MOUSE_DRAGGING_FINISHED));
    // updates camera target constraints
    m_parent.refresh_camera_scene_box();
}

References m_dragging, m_grabbers, m_parent, and on_stop_dragging().

Referenced by use_grabbers().

Here is the call graph for this function:

Here is the caller graph for this function:

draw_depth()

void GLGizmoSVG::draw_depth ( )

private

{
    ImGui::AlignTextToFramePadding();
    ImGuiWrapper::text(m_gui_cfg->translations.depth);
    ImGui::SameLine(m_gui_cfg->input_offset);
    ImGui::SetNextItemWidth(m_gui_cfg->input_width);
 
    bool use_inch = wxGetApp().app_config->get_bool("use_inches");
    double &value = m_volume_shape.projection.depth;
    constexpr double step = 1.;
    constexpr double step_fast = 10.;
    std::optional<double> result_scale;
    const char *size_format = "%.1f mm";
    double input = value;
    if (use_inch) {
        size_format = "%.2f in";
        // input in inches
        input *= GizmoObjectManipulation::mm_to_in * m_scale_depth.value_or(1.f);
        result_scale = GizmoObjectManipulation::in_to_mm / m_scale_depth.value_or(1.f);
    } else if (m_scale_depth.has_value()) {
        // scale input
        input *= (*m_scale_depth);
        result_scale = 1. / (*m_scale_depth);
    }
    
    const bool input_changed = ImGui::InputDouble("##depth", &input, step, step_fast, size_format);
    m_imgui->request_frames_while_held(); // ORCA auto-repeat of the +/- buttons
    if (input_changed) {
        if (result_scale.has_value())
            input *= (*result_scale);
        apply(input, limits.depth);
        if (!is_approx(input, value, 1e-4)){
            value = input;
            process();
        }
    } else if (ImGui::IsItemHovered())
        m_imgui->tooltip(_u8L("Size in emboss direction."), m_gui_cfg->max_tooltip_width);
}

References _u8L, Slic3r::apply(), Slic3r::GUI::GizmoObjectManipulation::in_to_mm, Slic3r::is_approx(), m_gui_cfg, Slic3r::GUI::GLGizmoBase::m_imgui, m_scale_depth, m_volume_shape, Slic3r::GUI::GizmoObjectManipulation::mm_to_in, process(), and Slic3r::GUI::ImGuiWrapper::text().

Referenced by draw_window().

Here is the call graph for this function:

Here is the caller graph for this function:

draw_distance()

void GLGizmoSVG::draw_distance ( )

private

{
    const EmbossProjection& projection = m_volume->emboss_shape->projection;
    bool use_surface = projection.use_surface;
    bool allowe_surface_distance = !use_surface && !m_volume->is_the_only_one_part();
 
    float prev_distance = m_distance.value_or(.0f);
    float min_distance = static_cast<float>(-2 * projection.depth);
    float max_distance = static_cast<float>(2 * projection.depth);
 
    m_imgui->disabled_begin(!allowe_surface_distance);
    ScopeGuard sg([imgui = m_imgui]() { imgui->disabled_end(); });
 
    ImGui::AlignTextToFramePadding();
    ImVec4 text_color = m_distance.has_value() ? ImGuiWrapper::COL_MODIFIED : ImGui::GetStyleColorVec4(ImGuiCol_Text); // ORCA use modified color on text
    ImGuiWrapper::text_colored(text_color, m_gui_cfg->translations.distance);
    ImGui::SameLine(m_gui_cfg->input_offset);
    ImGui::SetNextItemWidth(m_gui_cfg->input_width);
 
    bool use_inch = wxGetApp().app_config->get_bool("use_inches");
    const wxString move_tooltip = _L("Distance of the center of the SVG to the model surface.");
    bool is_moved = false;
    if (use_inch) {
        std::optional<float> distance_inch;
        if (m_distance.has_value()) distance_inch = (*m_distance * GizmoObjectManipulation::mm_to_in);
        min_distance = static_cast<float>(min_distance * GizmoObjectManipulation::mm_to_in);
        max_distance = static_cast<float>(max_distance * GizmoObjectManipulation::mm_to_in);
        if (m_imgui->slider_optional_float("##distance", m_distance, min_distance, max_distance, "%.3f in", 1.f, false, move_tooltip)) {
            if (distance_inch.has_value()) {
                m_distance = *distance_inch * GizmoObjectManipulation::in_to_mm;
            } else {
                m_distance.reset();
            }
            is_moved = true;
        }
    } else {
        if (m_imgui->slider_optional_float("##distance", m_distance, min_distance, max_distance, "%.2f mm", 1.f, false, move_tooltip)) 
            is_moved = true;
    }
    bool is_stop_sliding = m_imgui->get_last_slider_status().deactivated_after_edit;
    bool is_reseted = false;
    if (m_distance.has_value()) {
        if (reset_button(m_icons)) {
            m_distance.reset();
            is_reseted = true;
        } else if (ImGui::IsItemHovered())
            m_imgui->tooltip(_u8L("Reset distance"), m_gui_cfg->max_tooltip_width);
    }
 
    if (is_moved || is_reseted)
        do_local_z_move(m_parent.get_selection(), m_distance.value_or(.0f) - prev_distance);    
    if (is_stop_sliding || is_reseted)
        m_parent.do_move(move_snapshot_name);
}

References _L, _u8L, Slic3r::GUI::ImGuiWrapper::COL_MODIFIED, Slic3r::EmbossProjection::depth, Slic3r::GUI::do_local_z_move(), Slic3r::GUI::GizmoObjectManipulation::in_to_mm, m_distance, m_gui_cfg, m_icons, Slic3r::GUI::GLGizmoBase::m_imgui, Slic3r::GUI::GLGizmoBase::m_parent, m_volume, Slic3r::GUI::GizmoObjectManipulation::mm_to_in, text_color(), Slic3r::GUI::ImGuiWrapper::text_colored(), and Slic3r::EmbossProjection::use_surface.

Referenced by draw_window().

Here is the call graph for this function:

Here is the caller graph for this function:

draw_face_the_camera()

void GLGizmoSVG::draw_face_the_camera ( )

private

                                     {
    if (ImGui::Button(_u8L("Face the camera").c_str())) {
        const Camera &cam = wxGetApp().plater()->get_camera();
        auto wanted_up_limit = (m_keep_up) ? std::optional<double>(UP_LIMIT) : std::optional<double>{};
        if (face_selected_volume_to_camera(cam, m_parent, wanted_up_limit))
            volume_transformation_changed();
    }
}

References _u8L, Slic3r::GUI::face_selected_volume_to_camera(), m_keep_up, Slic3r::GUI::GLGizmoBase::m_parent, Slic3r::GUI::UP_LIMIT, and volume_transformation_changed().

Referenced by draw_window().

Here is the call graph for this function:

Here is the caller graph for this function:

draw_filename()

void GLGizmoSVG::draw_filename ( )

private

                              {
    const EmbossShape &es = *m_volume->emboss_shape;
    const EmbossShape::SvgFile &svg = *es.svg_file;
    if (m_filename_preview.empty()){
        // create filename preview
        if (!svg.path.empty()) {
            m_filename_preview = get_file_name(svg.path);
        } else if (!svg.path_in_3mf.empty()) {
            m_filename_preview = get_file_name(svg.path_in_3mf);
        }
 
        if (m_filename_preview.empty())
            // TRN - Preview of filename after clear local filepath.
            m_filename_preview = _u8L("Unknown filename");
        
        m_filename_preview = ImGuiWrapper::trunc(m_filename_preview, m_gui_cfg->input_width);
    }
 
    if (!m_shape_warnings.empty()){
        draw(get_icon(m_icons, IconType::exclamation, IconState::hovered));
        if (ImGui::IsItemHovered()) {
            std::string tooltip;
            for (const std::string &w: m_shape_warnings){
                if (w.empty())
                    continue;
                if (!tooltip.empty())
                    tooltip += "\n";
                tooltip += w;
            }
            m_imgui->tooltip(tooltip, m_gui_cfg->max_tooltip_width);
        }
        ImGui::SameLine();
    }
 
    // Remove space between filename and gray suffix ".svg"
    ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(0, 0));
    ImGui::AlignTextToFramePadding();
    ImGui::Text("%s", m_filename_preview.c_str());
    bool is_hovered = ImGui::IsItemHovered();
    ImGui::SameLine();
    m_imgui->text_colored(ImGuiWrapper::COL_GREY_LIGHT, ".svg");
    ImGui::PopStyleVar(); // ImGuiStyleVar_ItemSpacing 
 
    is_hovered |= ImGui::IsItemHovered();
    if (is_hovered) {
        std::string tooltip = GUI::format(_L("SVG file path is \"%1%\""), svg.path);
        m_imgui->tooltip(tooltip, m_gui_cfg->max_tooltip_width);
    }
 
    bool file_changed = false;
 
    // Re-Load button
    bool can_reload = !m_volume_shape.svg_file->path.empty();
    if (can_reload) {
        ImGui::SameLine();
        if (draw_clickable(m_icons, IconType::refresh)) {
            if (!boost::filesystem::exists(m_volume_shape.svg_file->path)) {
                m_volume_shape.svg_file->path.clear();
            } else {
                file_changed = true;
            }
        } else if (ImGui::IsItemHovered())
            m_imgui->tooltip(_u8L("Reload SVG file from disk."), m_gui_cfg->max_tooltip_width);
    }
 
    std::string tooltip = "";
    ImGuiComboFlags flags = ImGuiComboFlags_PopupAlignLeft | ImGuiComboFlags_NoPreview;
    ImGui::SameLine();
    ImGuiWrapper::push_combo_style(m_parent.get_scale());
    if (ImGui::BeginCombo("##file_options", nullptr, flags)) {
        ScopeGuard combo_sg([]() { ImGui::EndCombo(); });
 
        ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, {ImGui::GetStyle().FramePadding.x, 0});
        draw(get_icon(m_icons, IconType::change_file, IconState::hovered));
        ImGui::SameLine();
        if (ImGui::Selectable((_L("Change file") + dots).ToUTF8().data())) {
            std::string new_path = choose_svg_file();
            if (!new_path.empty()) {
                file_changed = true;
                EmbossShape::SvgFile svg_file_new;
                svg_file_new.path = new_path;
                m_volume_shape.svg_file = svg_file_new; // clear data
            }
        } else if (ImGui::IsItemHovered()) {
            tooltip = _u8L("Change to another SVG file.");
        }
 
        std::string forget_path = _u8L("Forget the file path");
        if (m_volume->emboss_shape->svg_file->path.empty()){
            draw(get_icon(m_icons, IconType::bake, IconState::disabled));
            ImGui::SameLine();
            m_imgui->text_colored(ImGuiWrapper::COL_GREY_DARK, forget_path.c_str());
        } else {
            draw(get_icon(m_icons, IconType::bake, IconState::hovered));
            ImGui::SameLine();
            if (ImGui::Selectable(forget_path.c_str())) {
                // set .svg_file.path_in_3mf to remember file name
                m_volume->emboss_shape->svg_file->path.clear();
                m_volume_shape.svg_file->path.clear();
                m_filename_preview.clear();
            } else if (ImGui::IsItemHovered()) {
                tooltip = _u8L("Do NOT save local path to 3MF file.\n"
                               "Also disables 'reload from disk' option.");
            }
        }
        
        //draw(get_icon(m_icons, IconType::bake));
        //ImGui::SameLine();
        //if (ImGui::Selectable(_u8L("Bake 2 ©").c_str())) {
        //    EmbossShape::SvgFile &svg = m_volume_shape.svg_file;
        //    std::stringstream ss;
        //    Slic3r::save(*svg.image, ss);
        //    svg.file_data = std::make_unique<std::string>(ss.str());
        //    svg.image     = nsvgParse(*svg.file_data);
        //    assert(svg.image.get() != NULL);
        //    if (svg.image.get() != NULL) {
        //        m_volume->emboss_shape->svg_file = svg; // copy - write changes into volume
        //    } else {
        //        svg = m_volume->emboss_shape->svg_file; // revert changes
        //    }
        //} else if (ImGui::IsItemHovered()) {
        //    ImGui::SetTooltip("%s", _u8L("Use only paths from svg - recreate svg").c_str());
        //}
                
        draw(get_icon(m_icons, IconType::bake, IconState::hovered));
        ImGui::SameLine();
        // TRN: An menu option to convert the SVG into an unmodifiable model part.
        if (ImGui::Selectable(_u8L("Bake").c_str())) {
            m_volume->emboss_shape.reset();
            close();
        } else if (ImGui::IsItemHovered()) {
            // TRN: Tooltip for the menu item.
            tooltip = _u8L("Bake into model as uneditable part");
        }
 
        draw(get_icon(m_icons, IconType::save, IconState::activable));
        ImGui::SameLine();
        if (ImGui::Selectable((_L("Save as") + dots).ToUTF8().data())) {
            wxWindow *parent = nullptr;
            GUI::FileType file_type  = FT_SVG;
            wxString wildcard = file_wildcards(file_type);
            wxString dlg_title = _L("Save SVG file");
            const EmbossShape::SvgFile& svg = *m_volume_shape.svg_file;
            wxString dlg_file = from_u8(get_file_name(((!svg.path.empty()) ? svg.path : svg.path_in_3mf))) + ".svg";
            wxFileDialog dlg(parent, dlg_title, last_used_directory, dlg_file, wildcard, wxFD_SAVE | wxFD_OVERWRITE_PROMPT);
            if (dlg.ShowModal() == wxID_OK ){
                last_used_directory = dlg.GetDirectory();
                wxString out_path = dlg.GetPath();
                std::string path{out_path.c_str()};
                //Slic3r::save(*m_volume_shape.svg_file.image, path);
 
                std::ofstream stream(path);
                if (stream.is_open()){
                    stream << *svg.file_data;
 
                    // change source file
                    m_filename_preview.clear();
                    m_volume_shape.svg_file->path = path;
                    m_volume_shape.svg_file->path_in_3mf.clear(); // possible change name
                    m_volume->emboss_shape->svg_file = m_volume_shape.svg_file; // copy - write changes into volume
                } else {
                    BOOST_LOG_TRIVIAL(error) << "Opening file: \"" << path << "\" Failed";
                }
 
            }
        } else if (ImGui::IsItemHovered()) {
            tooltip = _u8L("Save as SVG file.");
        }
 
        //draw(get_icon(m_icons, IconType::save));
        //ImGui::SameLine();
        //if (ImGui::Selectable((_L("Save used as") + dots).ToUTF8().data())) {
        //    GUI::FileType file_type  = FT_SVG;
        //    wxString wildcard = file_wildcards(file_type);
        //    wxString dlg_title = _L("Export SVG file:");
        //    wxString dlg_dir = from_u8(wxGetApp().app_config->get_last_dir());
        //    const EmbossShape::SvgFile& svg = m_volume_shape.svg_file;
        //    wxString dlg_file = from_u8(get_file_name(((!svg.path.empty()) ? svg.path : svg.path_in_3mf))) + ".svg";
        //    wxFileDialog dlg(nullptr, dlg_title, dlg_dir, dlg_file, wildcard, wxFD_SAVE | wxFD_OVERWRITE_PROMPT);
        //    if (dlg.ShowModal() == wxID_OK ){
        //        wxString out_path = dlg.GetPath();        
        //        std::string path{out_path.c_str()};
        //        Slic3r::save(*m_volume_shape.svg_file.image, path);
        //    }
        //} else if (ImGui::IsItemHovered()) {
        //    ImGui::SetTooltip("%s", _u8L("Save only used path as '.svg' file").c_str());
        //}
        ImGui::PopStyleVar(1);
    }
    ImGuiWrapper::pop_combo_style();
    if (!tooltip.empty())
        m_imgui->tooltip(tooltip, m_gui_cfg->max_tooltip_width);
 
    if (file_changed) {
        float scale = get_scale_for_tolerance();
        double tes_tol = get_tesselation_tolerance(scale);
        EmbossShape es_ = select_shape(m_volume_shape.svg_file->path, tes_tol);
        m_volume_shape.svg_file = std::move(es_.svg_file);
        m_volume_shape.shapes_with_ids = std::move(es_.shapes_with_ids);
        m_volume_shape.final_shape = {}; // clear cache
        m_shape_warnings = create_shape_warnings(m_volume_shape, scale);
        init_texture(m_texture, m_volume_shape.shapes_with_ids, m_gui_cfg->texture_max_size_px, m_shape_warnings);
        process();
    }
}

References _L, _u8L, anonymous_namespace{GLGizmoEmboss.cpp}::activable, close(), Slic3r::GUI::ImGuiWrapper::COL_GREY_DARK, Slic3r::GUI::ImGuiWrapper::COL_GREY_LIGHT, anonymous_namespace{GLGizmoEmboss.cpp}::disabled, Slic3r::GUI::dots(), Slic3r::GUI::draw(), anonymous_namespace{GLGizmoEmboss.cpp}::exclamation, Slic3r::EmbossShape::SvgFile::file_data, Slic3r::GUI::file_wildcards(), Slic3r::GUI::format(), Slic3r::GUI::from_u8(), Slic3r::GUI::FT_SVG, get_scale_for_tolerance(), anonymous_namespace{GLGizmoEmboss.cpp}::hovered, m_filename_preview, m_gui_cfg, m_icons, Slic3r::GUI::GLGizmoBase::m_imgui, Slic3r::GUI::GLGizmoBase::m_parent, m_shape_warnings, m_texture, m_volume, m_volume_shape, Slic3r::EmbossShape::SvgFile::path, Slic3r::EmbossShape::SvgFile::path_in_3mf, Slic3r::GUI::ImGuiWrapper::pop_combo_style(), process(), Slic3r::GUI::ImGuiWrapper::push_combo_style(), anonymous_namespace{GLGizmoEmboss.cpp}::save, scale(), Slic3r::EmbossShape::shapes_with_ids, Slic3r::EmbossShape::svg_file, and Slic3r::GUI::ImGuiWrapper::trunc().

Referenced by draw_window().

Here is the call graph for this function:

Here is the caller graph for this function:

draw_mirroring()

void GLGizmoSVG::draw_mirroring ( )

private

{
    ImGui::AlignTextToFramePadding();
    ImGui::Text("%s", m_gui_cfg->translations.mirror.c_str());
    ImGui::SameLine(m_gui_cfg->input_offset);
    Axis axis = Axis::UNKNOWN_AXIS;
    if (draw_clickable(m_icons, IconType::reflection_x)) {
        axis = Axis::X;
    } else if (ImGui::IsItemHovered()) {
        m_imgui->tooltip(_u8L("Mirror vertically"), m_gui_cfg->max_tooltip_width);
    }
 
    ImGui::SameLine();
    if (draw_clickable(m_icons, IconType::reflection_y)) {
        axis = Axis::Y;
    } else if (ImGui::IsItemHovered()) {
        m_imgui->tooltip(_u8L("Mirror horizontally"), m_gui_cfg->max_tooltip_width);
    }
 
    if (axis != Axis::UNKNOWN_AXIS){
        Selection &selection = m_parent.get_selection();
        selection.setup_cache();
 
        auto selection_mirror_fnc = [&selection, &axis](){
            selection.mirror(axis, get_drag_transformation_type(selection));
        };
        selection_transform(selection, selection_mirror_fnc);
        m_parent.do_mirror(L("Set Mirror"));
 
        // Mirror is ignoring keep up !!
        if (m_keep_up)
            m_angle = calc_angle(selection);
 
        volume_transformation_changed();
 
 
        if (m_volume_shape.projection.use_surface)
            process();
    }
}

References _u8L, Slic3r::GUI::calc_angle(), Slic3r::GUI::get_drag_transformation_type(), L, m_angle, m_gui_cfg, m_icons, Slic3r::GUI::GLGizmoBase::m_imgui, m_keep_up, Slic3r::GUI::GLGizmoBase::m_parent, m_volume_shape, Slic3r::GUI::Selection::mirror(), process(), Slic3r::GUI::selection_transform(), Slic3r::GUI::Selection::setup_cache(), Slic3r::UNKNOWN_AXIS, volume_transformation_changed(), Slic3r::X, and Slic3r::Y.

Referenced by draw_window().

Here is the call graph for this function:

Here is the caller graph for this function:

draw_model_type()

void GLGizmoSVG::draw_model_type ( )

private

{
    //ImGui::AlignTextToFramePadding();
    bool is_last_solid_part = m_volume->is_the_only_one_part();
    std::string title = _u8L("Operation");
    if (is_last_solid_part) {
        ImVec4 color{.5f, .5f, .5f, 1.f};
        m_imgui->text_colored(color, title.c_str());
    } else {
        ImGui::Text("%s", title.c_str());
    }
 
    std::optional<ModelVolumeType> new_type;
    ModelVolumeType modifier = ModelVolumeType::PARAMETER_MODIFIER;
    ModelVolumeType negative = ModelVolumeType::NEGATIVE_VOLUME;
    ModelVolumeType part = ModelVolumeType::MODEL_PART;
    ModelVolumeType type = m_volume->type();
 
    ImGui::SameLine();
 
    //TRN EmbossOperation
    ImGuiWrapper::push_radio_style(m_parent.get_scale()); //ORCA
    if (ImGui::RadioButton(_u8L("Join").c_str(), type == part))
        new_type = part;
    else if (ImGui::IsItemHovered())
        m_imgui->tooltip(_u8L("Click to change text into object part."), m_gui_cfg->max_tooltip_width);
    ImGui::SameLine();
 
    std::string last_solid_part_hint = _u8L("You can't change a type of the last solid part of the object.");
    if (ImGui::RadioButton(_u8L_CONTEXT(L_CONTEXT("Cut", "EmbossOperation"), "EmbossOperation").c_str(), type == negative))
        new_type = negative;
    else if (ImGui::IsItemHovered()) {
        if (is_last_solid_part)
            m_imgui->tooltip(last_solid_part_hint, m_gui_cfg->max_tooltip_width);
        else if (type != negative)
            m_imgui->tooltip(_u8L("Click to change part type into negative volume."), m_gui_cfg->max_tooltip_width);
    }
 
    // In simple mode are not modifiers
    if (wxGetApp().plater()->printer_technology() != ptSLA && wxGetApp().get_mode() != ConfigOptionMode::comSimple) {
        ImGui::SameLine();
        if (ImGui::RadioButton(_u8L("Modifier").c_str(), type == modifier))
            new_type = modifier;
        else if (ImGui::IsItemHovered()) {
            if (is_last_solid_part)
                m_imgui->tooltip(last_solid_part_hint, m_gui_cfg->max_tooltip_width);
            else if (type != modifier)
                m_imgui->tooltip(_u8L("Click to change part type into modifier."), m_gui_cfg->max_tooltip_width);
        }
    }
    ImGuiWrapper::pop_radio_style();
 
    if (m_volume != nullptr && new_type.has_value() && !is_last_solid_part) {
        GUI_App &app    = wxGetApp();
        Plater * plater = app.plater();
        // TRN: This is the name of the action that shows in undo/redo stack (changing part type from SVG to something else).
        Plater::TakeSnapshot snapshot(plater, _u8L("Change SVG Type"), UndoRedo::SnapshotType::GizmoAction);
        m_volume->set_type(*new_type);
 
        bool is_volume_move_inside  = (type == part);
        bool is_volume_move_outside = (*new_type == part);
         // Update volume position when switch (from part) or (into part)
        if ((is_volume_move_inside || is_volume_move_outside))
            process();
 
        // inspiration in ObjectList::set_volume_type()
        // how to view correct side panel with objects
        ObjectList *obj_list = app.obj_list();
        wxDataViewItemArray sel = obj_list->reorder_volumes_and_get_selection(
            obj_list->get_selected_obj_idx(),
            [volume = m_volume](const ModelVolume *vol) { return vol == volume; });
        if (!sel.IsEmpty()) obj_list->select_item(sel.front());       
 
        // NOTE: on linux, function reorder_volumes_and_get_selection call GLCanvas3D::reload_scene(refresh_immediately = false)
        // which discard m_volume pointer and set it to nullptr also selection is cleared so gizmo is automaticaly closed
        auto &mng = m_parent.get_gizmos_manager();
        if (mng.get_current_type() != GLGizmosManager::Svg)
            mng.open_gizmo(GLGizmosManager::Svg);
        // TODO: select volume back - Ask @Sasa
    }
}

References _u8L, _u8L_CONTEXT, Slic3r::comSimple, Slic3r::UndoRedo::GizmoAction, L_CONTEXT, m_gui_cfg, Slic3r::GUI::GLGizmoBase::m_imgui, Slic3r::GUI::GLGizmoBase::m_parent, m_volume, Slic3r::MODEL_PART, Slic3r::NEGATIVE_VOLUME, Slic3r::GUI::GUI_App::obj_list(), Slic3r::GUI::obj_list(), Slic3r::PARAMETER_MODIFIER, Slic3r::GUI::GUI_App::plater(), Slic3r::GUI::plater(), Slic3r::GUI::ImGuiWrapper::pop_radio_style(), Slic3r::GUI::printer_technology(), process(), Slic3r::ptSLA, Slic3r::GUI::ImGuiWrapper::push_radio_style(), and Slic3r::GUI::GLGizmosManager::Svg.

Referenced by draw_window().

Here is the call graph for this function:

Here is the caller graph for this function:

draw_preview()

void GLGizmoSVG::draw_preview ( )

private

                             {
    // init texture when not initialized yet.
    // drag&drop is out of rendering scope so texture must be created on this place
    if (m_texture.id == 0) {
        const ExPolygonsWithIds &shapes = m_volume->emboss_shape->shapes_with_ids;
        init_texture(m_texture, shapes, m_gui_cfg->texture_max_size_px, m_shape_warnings);
    }
 
    //::draw(m_volume_shape.shapes_with_ids, m_gui_cfg->texture_max_size_px);
 
    if (m_texture.id != 0) {
        ImTextureID id = (void *) static_cast<intptr_t>(m_texture.id);
        ImVec2      s(m_texture.width, m_texture.height);
 
        std::optional<float> spacing;
        // is texture over full height?
        if (m_texture.height != m_gui_cfg->texture_max_size_px) {
            spacing = (m_gui_cfg->texture_max_size_px - m_texture.height) / 2.f;
            ImGui::SetCursorPosY(ImGui::GetCursorPosY() + *spacing);
        }
        // is texture over full width?
        unsigned window_width = static_cast<unsigned>(
            ImGui::GetWindowSize().x - 2*ImGui::GetStyle().WindowPadding.x);
        if (window_width > m_texture.width){
            float space = (window_width - m_texture.width) / 2.f;
            ImGui::SetCursorPosX(ImGui::GetCursorPosX() + space);
        }
 
        ImGui::Image(id, s);
        //if(ImGui::IsItemHovered()){            
        //    const EmbossShape &es = *m_volume->emboss_shape;
        //    size_t count_of_shapes = get_shapes_count(*es.svg_file.image);
        //    size_t count_of_expolygons = 0;
        //    size_t count_of_points = 0;
        //    for (const auto &shape : es.shapes_with_ids) {
        //        for (const ExPolygon &expoly : shape.expoly){
        //            ++count_of_expolygons;
        //            count_of_points += count_points(expoly);
        //        }
        //    }
        //    // Do not translate it is only for debug
        //    std::string tooltip = GUI::format("%1% shapes, which create %2% polygons with %3% line segments",
        //        count_of_shapes, count_of_expolygons, count_of_points);
        //    ImGui::SetTooltip("%s", tooltip.c_str());
        //}
                
        if (spacing.has_value())
            ImGui::SetCursorPosY(ImGui::GetCursorPosY() + *spacing);        
    }    
}

References m_gui_cfg, m_shape_warnings, m_texture, and m_volume.

Referenced by draw_window().

Here is the caller graph for this function:

draw_rotation()

void GLGizmoSVG::draw_rotation ( )

private

{
    ImGui::AlignTextToFramePadding();
    ImVec4 text_color = m_angle.has_value() ? ImGuiWrapper::COL_MODIFIED : ImGui::GetStyleColorVec4(ImGuiCol_Text); // ORCA use modified color on text
    ImGuiWrapper::text_colored(text_color, m_gui_cfg->translations.rotation);
    ImGui::SameLine(m_gui_cfg->input_offset);
    ImGui::SetNextItemWidth(m_gui_cfg->input_width);
 
    // slider for Clockwise angle in degress
    // stored angle is optional CCW and in radians
    // Convert stored value to degress
    // minus create clockwise roation from CCW
    float angle = m_angle.value_or(0.f);
    float angle_deg = static_cast<float>(-angle * 180 / M_PI);
    if (m_imgui->slider_float("##angle", &angle_deg, limits.angle.min, limits.angle.max, u8"%.2f °", 1.f, false, _L("Rotate text Clockwise."))){
        // convert back to radians and CCW
        double angle_rad = -angle_deg * M_PI / 180.0;
        Geometry::to_range_pi_pi(angle_rad);                
 
        double diff_angle = angle_rad - angle;
        
        do_local_z_rotate(m_parent.get_selection(), diff_angle);
 
        // calc angle after rotation
        m_angle = calc_angle(m_parent.get_selection());
        
        // recalculate for surface cut
        if (m_volume->emboss_shape->projection.use_surface)
            process();
    }
    bool is_stop_sliding = m_imgui->get_last_slider_status().deactivated_after_edit;
 
    // Reset button
    bool is_reseted = false;
    if (m_angle.has_value()) {
        if (reset_button(m_icons)) {
            do_local_z_rotate(m_parent.get_selection(), -(*m_angle));
            m_angle.reset();
 
            // recalculate for surface cut
            if (m_volume->emboss_shape->projection.use_surface)
                process();
 
            is_reseted = true;
        } else if (ImGui::IsItemHovered())
            m_imgui->tooltip(_u8L("Reset rotation"), m_gui_cfg->max_tooltip_width);
    }
 
    // Apply rotation on model (backend)
    if (is_stop_sliding || is_reseted)
        m_parent.do_rotate(rotation_snapshot_name);    
 
    // Keep up - lock button icon
    if (!m_volume->is_the_only_one_part()) {
        ImGui::SameLine(m_gui_cfg->lock_offset);
        const IconManager::Icon &icon       = get_icon(m_icons, m_keep_up ? IconType::lock : IconType::unlock, IconState::activable);
        const IconManager::Icon &icon_hover = get_icon(m_icons, m_keep_up ? IconType::lock : IconType::unlock, IconState::hovered);
        if (button(icon, icon_hover, icon))
            m_keep_up = !m_keep_up;    
        if (ImGui::IsItemHovered())
            m_imgui->tooltip(_u8L("Lock/unlock rotation angle when dragging above the surface."), m_gui_cfg->max_tooltip_width);
    }
}

References _L, _u8L, anonymous_namespace{GLGizmoEmboss.cpp}::activable, Slic3r::angle(), Slic3r::GUI::button(), Slic3r::GUI::calc_angle(), Slic3r::GUI::ImGuiWrapper::COL_MODIFIED, Slic3r::GUI::do_local_z_rotate(), anonymous_namespace{GLGizmoEmboss.cpp}::hovered, anonymous_namespace{GLGizmoEmboss.cpp}::lock, m_angle, m_gui_cfg, m_icons, Slic3r::GUI::GLGizmoBase::m_imgui, m_keep_up, Slic3r::GUI::GLGizmoBase::m_parent, M_PI, m_volume, process(), text_color(), Slic3r::GUI::ImGuiWrapper::text_colored(), Slic3r::Geometry::to_range_pi_pi(), and anonymous_namespace{GLGizmoEmboss.cpp}::unlock.

Referenced by draw_window().

Here is the call graph for this function:

Here is the caller graph for this function:

draw_size()

void GLGizmoSVG::draw_size ( )

private

{
    ImGui::AlignTextToFramePadding();
    bool can_reset = m_scale_width.has_value() || m_scale_height.has_value();
    ImVec4 text_color = can_reset ? ImGuiWrapper::COL_MODIFIED : ImGui::GetStyleColorVec4(ImGuiCol_Text); // ORCA use modified color on text
    ImGuiWrapper::text_colored(text_color, m_gui_cfg->translations.size);
    if (ImGui::IsItemHovered()){
        size_t count_points = 0;
        for (const auto &s : m_volume_shape.shapes_with_ids)
            count_points += Slic3r::count_points(s.expoly);
        // TRN: The placeholder contains a number.
        m_imgui->tooltip(GUI::format(_L("Scale also changes amount of curve samples (%1%)"), count_points), m_gui_cfg->max_tooltip_width);
    }
 
    bool use_inch = wxGetApp().app_config->get_bool("use_inches");
    
    Point size = m_shape_bb.size();
    double width = size.x() * m_volume_shape.scale * m_scale_width.value_or(1.f);
    if (use_inch) width *= GizmoObjectManipulation::mm_to_in;    
    double height = size.y() * m_volume_shape.scale * m_scale_height.value_or(1.f);
    if (use_inch) height *= GizmoObjectManipulation::mm_to_in;
 
    const auto is_valid_scale_ratio = [limit = &limits.relative_scale_ratio](double ratio) {
        if (std::fabs(ratio - 1.) < limit->min)
            return false; // too small ratio --> without effect
 
        if (ratio > limit->max)
            return false;
 
        if (ratio < 1e-4) 
            return false; // negative scale is not allowed
 
        return true;    
    };
 
    std::optional<Vec3d> new_relative_scale;
    bool make_snap = false;
 
    if (m_keep_ratio) {
        std::stringstream ss;
        ss << std::setprecision(2) << std::fixed << width << " x " << height << " " << (use_inch ? _L_CONTEXT("in", "inches") : _L("mm"));
 
        ImGui::SameLine(m_gui_cfg->input_offset);
        ImGui::SetNextItemWidth(m_gui_cfg->input_width);
 
        const MinMax<float> &minmax = use_inch ? limits.ui_size_in : limits.ui_size;
        // convert to float for slider
        float width_f = static_cast<float>(width);
        if (m_imgui->slider_float("##width_size_slider", &width_f, minmax.min, minmax.max, ss.str().c_str(), 1.f, false)) {
            double width_ratio = width_f / width;
            if (is_valid_scale_ratio(width_ratio)) {
                m_scale_width      = m_scale_width.value_or(1.f) * width_ratio;
                m_scale_height     = m_scale_height.value_or(1.f) * width_ratio;
                new_relative_scale = Vec3d(width_ratio, width_ratio, 1.);
            }
        }
        if (m_imgui->get_last_slider_status().deactivated_after_edit)
            make_snap = true; // only last change of slider make snap
    } else {
        ImGuiInputTextFlags flags = 0;
 
        float space         = m_gui_cfg->icon_width / 2;
        float input_width   = m_gui_cfg->input_width / 2 - space / 2;
        float second_offset = m_gui_cfg->input_offset + input_width + space;
 
        const char *size_format = (use_inch) ? "%.2f in" : "%.1f mm";
        double step = -1.0;
        double fast_step = -1.0;
 
        ImGui::SameLine(m_gui_cfg->input_offset);
        ImGui::SetNextItemWidth(input_width);
        double prev_width = width;
        if (ImGui::InputDouble("##width", &width, step, fast_step, size_format, flags)) {
            double width_ratio = width / prev_width;
            if (is_valid_scale_ratio(width_ratio)) {
                m_scale_width = m_scale_width.value_or(1.f) * width_ratio;
                new_relative_scale = Vec3d(width_ratio, 1., 1.);
                make_snap = true;
            }
        }
        if (ImGui::IsItemHovered())
            m_imgui->tooltip(_u8L("Width of SVG."), m_gui_cfg->max_tooltip_width);
 
        ImGui::SameLine(second_offset);
        ImGui::SetNextItemWidth(input_width);
        double prev_height = height;
        if (ImGui::InputDouble("##height", &height, step, fast_step, size_format, flags)) {
            double height_ratio = height / prev_height;
            if (is_valid_scale_ratio(height_ratio)) {
                m_scale_height = m_scale_height.value_or(1.f) * height_ratio;
                new_relative_scale  = Vec3d(1., height_ratio, 1.);
                make_snap = true;
            }
        }
        if (ImGui::IsItemHovered())
            m_imgui->tooltip(_u8L("Height of SVG."), m_gui_cfg->max_tooltip_width);
    }
 
    // Lock on ratio m_keep_ratio
    ImGui::SameLine(m_gui_cfg->lock_offset);
    const IconManager::Icon &icon       = get_icon(m_icons, m_keep_ratio ? IconType::lock : IconType::unlock, IconState::activable);
    const IconManager::Icon &icon_hover = get_icon(m_icons, m_keep_ratio ? IconType::lock : IconType::unlock, IconState::hovered);
    if (button(icon, icon_hover, icon))
        m_keep_ratio = !m_keep_ratio;    
    if (ImGui::IsItemHovered())
        m_imgui->tooltip(_u8L("Lock/unlock the aspect ratio of the SVG."), m_gui_cfg->max_tooltip_width);
    
 
    // reset button
    //bool can_reset = m_scale_width.has_value() || m_scale_height.has_value(); // ORCA update variable above if condition change
    if (can_reset) {
        if (reset_button(m_icons)) {
            new_relative_scale = Vec3d(1./m_scale_width.value_or(1.f), 1./m_scale_height.value_or(1.f), 1.);
            make_snap = true;
        } else if (ImGui::IsItemHovered())
            m_imgui->tooltip(_u8L("Reset scale"), m_gui_cfg->max_tooltip_width);
    }
 
    if (new_relative_scale.has_value()){
        Selection &selection = m_parent.get_selection();
        selection.setup_cache();
 
        auto selection_scale_fnc = [&selection, rel_scale = *new_relative_scale]() {
            selection.scale(rel_scale, get_drag_transformation_type(selection));
        };        
        selection_transform(selection, selection_scale_fnc);
 
        std::string snap_name; // Empty mean do not store on undo/redo stack
        m_parent.do_scale(snap_name);
        wxGetApp().obj_manipul()->set_dirty();
        // should be the almost same
        calculate_scale();
                
        const NSVGimage *img = m_volume_shape.svg_file->image.get();
        assert(img != NULL);
        if (img != NULL){
            NSVGLineParams params{get_tesselation_tolerance(get_scale_for_tolerance())};
            m_volume_shape.shapes_with_ids = create_shape_with_ids(*img, params);
            m_volume_shape.final_shape = {}; // reset cache for final shape
            if (!make_snap) // Be carefull: Last change may be without change of scale
                process(false);
        }
    }
 
    if (make_snap)
        process(); // make undo/redo snap-shot
}

References _L, _L_CONTEXT, _u8L, anonymous_namespace{GLGizmoEmboss.cpp}::activable, Slic3r::GUI::button(), calculate_scale(), Slic3r::GUI::ImGuiWrapper::COL_MODIFIED, Slic3r::count_points(), Slic3r::create_shape_with_ids(), Slic3r::GUI::format(), Slic3r::GUI::get_drag_transformation_type(), get_scale_for_tolerance(), anonymous_namespace{GLGizmoEmboss.cpp}::hovered, anonymous_namespace{GLGizmoEmboss.cpp}::lock, m_gui_cfg, m_icons, Slic3r::GUI::GLGizmoBase::m_imgui, m_keep_ratio, Slic3r::GUI::GLGizmoBase::m_parent, m_scale_height, m_scale_width, m_shape_bb, m_volume_shape, Slic3r::MinMax< T >::max, Slic3r::MinMax< T >::min, Slic3r::GUI::GizmoObjectManipulation::mm_to_in, process(), Slic3r::GUI::Selection::scale(), Slic3r::GUI::selection_transform(), Slic3r::GUI::Selection::setup_cache(), text_color(), Slic3r::GUI::ImGuiWrapper::text_colored(), and anonymous_namespace{GLGizmoEmboss.cpp}::unlock.

Referenced by draw_window().

Here is the call graph for this function:

Here is the caller graph for this function:

draw_use_surface()

void GLGizmoSVG::draw_use_surface ( )

private

{
    bool can_use_surface = (m_volume->emboss_shape->projection.use_surface)? true : // already used surface must have option to uncheck
        !m_volume->is_the_only_one_part();
    m_imgui->disabled_begin(!can_use_surface);
    ScopeGuard sc([imgui = m_imgui]() { imgui->disabled_end(); });
 
    ImGui::AlignTextToFramePadding();
    ImGuiWrapper::text(m_gui_cfg->translations.use_surface);
    ImGui::SameLine(m_gui_cfg->input_offset);
 
    if (m_imgui->bbl_checkbox("##useSurface", m_volume_shape.projection.use_surface))
        process();
}

References m_gui_cfg, Slic3r::GUI::GLGizmoBase::m_imgui, m_volume, m_volume_shape, process(), and Slic3r::GUI::ImGuiWrapper::text().

Referenced by draw_window().

Here is the call graph for this function:

Here is the caller graph for this function:

draw_window()

void GLGizmoSVG::draw_window ( )

private

{
    assert(m_volume != nullptr);
    assert(m_volume_id.valid());
    if (m_volume == nullptr ||
        m_volume_id.invalid()) {
        ImGui::Text("%s", _u8L("Not valid state please report reproduction steps on GitHub").c_str());
        return;
    }
 
    assert(m_volume->emboss_shape.has_value());
    if (!m_volume->emboss_shape.has_value()) {
        ImGui::Text("%s", _u8L("No embossed file").c_str());
        return;
    }
 
    assert(m_volume->emboss_shape->svg_file.has_value());
    if (!m_volume->emboss_shape->svg_file.has_value()){
        ImGui::Text("%s", _u8L("Missing SVG file in embossed shape").c_str());
        return;
    }
 
    assert(m_volume->emboss_shape->svg_file->file_data != nullptr);
    if (m_volume->emboss_shape->svg_file->file_data == nullptr){
        ImGui::Text("%s", _u8L("Missing data of SVG file").c_str());
        return;
    }
 
    draw_preview();
    draw_filename();
 
    // Is SVG baked?
    if (m_volume == nullptr) return;
 
    ImGui::Separator();
 
    ImGui::Indent(m_gui_cfg->icon_width);
    draw_depth();
    draw_size();
    draw_use_surface();
 
    draw_distance();
    draw_rotation();
    draw_mirroring();
    draw_face_the_camera();
 
    ImGui::Unindent(m_gui_cfg->icon_width);  
 
    if (!m_volume->is_the_only_one_part()) {
        ImGui::Separator();
        draw_model_type();
    }
}

References _u8L, draw_depth(), draw_distance(), draw_face_the_camera(), draw_filename(), draw_mirroring(), draw_model_type(), draw_preview(), draw_rotation(), draw_size(), draw_use_surface(), m_gui_cfg, m_volume, and m_volume_id.

Referenced by on_render_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

format()

std::string Slic3r::GUI::GLGizmoBase::format ( float value, unsigned int decimals ) const

protectedinherited

{
    return Slic3r::string_printf("%.*f", decimals, value);
}

References Slic3r::string_printf().

Referenced by Slic3r::GUI::GLGizmoCut3D::get_tooltip(), Slic3r::GUI::GLGizmoMove3D::get_tooltip(), Slic3r::GUI::GLGizmoRotate::get_tooltip(), Slic3r::GUI::GLGizmoScale3D::get_tooltip(), Slic3r::GUI::GLGizmoEmboss::init_font_name_texture(), Slic3r::GUI::GLGizmoSimplify::on_render_input_window(), Slic3r::GUI::GLGizmoCut3D::render_angle_input(), Slic3r::GUI::GLGizmoCut3D::render_slider_input(), Slic3r::GUI::GLGizmoCut3D::render_slider_two_input(), Slic3r::GUI::GLGizmoCut3D::render_snap_specific_input(), Slic3r::GUI::GLGizmoEmboss::rev_input(), Slic3r::GUI::GLGizmoEmboss::rev_input_mm(), Slic3r::GUI::GLGizmoEmboss::rev_slider(), Slic3r::GUI::GLGizmoEmboss::rev_slider(), and Slic3r::GUI::GLGizmoEmboss::rev_slider().

Here is the call graph for this function:

Here is the caller graph for this function:

get_action_snapshot_name()

std::string GLGizmoSVG::get_action_snapshot_name ( ) const

overrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

{ return _u8L("SVG actions"); }

References _u8L.

get_count()

int Slic3r::GUI::GLGizmoBase::get_count ( )

inlineinherited

{ return ++count; }

References count.

get_gizmo_entering_text()

std::string GLGizmoSVG::get_gizmo_entering_text ( ) const

overrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

{ return _u8L("Enter SVG gizmo"); }

References _u8L.

get_gizmo_leaving_text()

std::string GLGizmoSVG::get_gizmo_leaving_text ( ) const

overrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

{ return _u8L("Leave SVG gizmo"); }

References _u8L.

get_gizmo_name()

std::string Slic3r::GUI::GLGizmoBase::get_gizmo_name ( )

inlineinherited

{ return on_get_name(); }

References on_get_name().

Here is the call graph for this function:

get_hover_id()

int Slic3r::GUI::GLGizmoBase::get_hover_id ( ) const

inlineinherited

{ return m_hover_id; }

References m_hover_id.

Referenced by Slic3r::GUI::GLCanvas3D::_scene_cache_key(), Slic3r::GUI::GLGizmosManager::grabber_contains_mouse(), Slic3r::GUI::GLGizmoBrimEars::on_mouse(), Slic3r::GUI::GLGizmoCut3D::on_mouse(), Slic3r::GUI::GLGizmoMeshBoolean::on_mouse(), and Slic3r::GUI::GLGizmoPainterBase::on_mouse().

Here is the caller graph for this function:

get_icon_filename()

const std::string & Slic3r::GUI::GLGizmoBase::get_icon_filename ( ) const

inlineinherited

{ return m_icon_filename; }

References m_icon_filename.

get_name()

std::string Slic3r::GUI::GLGizmoBase::get_name ( bool include_shortcut = true ) const

inherited

{
    const std::string name = on_get_name();
    return include_shortcut && m_shortcut.has_value() ? wxGetApp().shortcuts().with_key(name, *m_shortcut) : name;
}

References m_shortcut, and on_get_name().

Referenced by Slic3r::GUI::GLGizmoAssembly::on_render_input_window(), Slic3r::GUI::GLGizmoBrimEars::on_render_input_window(), Slic3r::GUI::GLGizmoCut3D::on_render_input_window(), Slic3r::GUI::GLGizmoEmboss::on_render_input_window(), Slic3r::GUI::GLGizmoFdmSupports::on_render_input_window(), Slic3r::GUI::GLGizmoFuzzySkin::on_render_input_window(), Slic3r::GUI::GLGizmoMeasure::on_render_input_window(), Slic3r::GUI::GLGizmoMmuSegmentation::on_render_input_window(), Slic3r::GUI::GLGizmoSeam::on_render_input_window(), Slic3r::GUI::GLGizmoTextureDisplacement::on_render_input_window(), and Slic3r::GUI::GLGizmosManager::update_hover_state().

Here is the call graph for this function:

Here is the caller graph for this function:

get_requirements()

CommonGizmosDataID Slic3r::GUI::GLGizmoBase::get_requirements ( ) const

inlineinherited

{ return on_get_requirements(); }

References on_get_requirements().

Here is the call graph for this function:

get_scale_for_tolerance()

float GLGizmoSVG::get_scale_for_tolerance ( )

private

                                         { 
    return std::max(m_scale_width.value_or(1.f), m_scale_height.value_or(1.f)); }

References m_scale_height, and m_scale_width.

Referenced by draw_filename(), draw_size(), and set_volume_by_selection().

Here is the caller graph for this function:

get_sprite_id()

unsigned int Slic3r::GUI::GLGizmoBase::get_sprite_id ( ) const

inlineinherited

{ return m_sprite_id; }

References m_sprite_id.

Referenced by Slic3r::GUI::GLGizmosManager::do_render_overlay().

Here is the caller graph for this function:

get_state()

EState Slic3r::GUI::GLGizmoBase::get_state ( ) const

inlineinherited

{ return m_state; }

References m_state.

Referenced by Slic3r::GUI::GLGizmosManager::activate_gizmo(), Slic3r::GUI::GLGizmoFdmSupports::on_set_state(), Slic3r::GUI::GLGizmoMmuSegmentation::on_set_state(), Slic3r::GUI::GLGizmoMove3D::on_set_state(), Slic3r::GUI::GLGizmoRotate3D::on_set_state(), Slic3r::GUI::GLGizmoScale3D::on_set_state(), Slic3r::GUI::GLGizmoSeam::on_set_state(), and Slic3r::GUI::GLGizmoFlatten::set_flattening_data().

Here is the caller graph for this function:

get_tooltip()

virtual std::string Slic3r::GUI::GLGizmoBase::get_tooltip ( ) const

inlinevirtualinherited

Mouse tooltip text.

Returns

Text to be visible in mouse tooltip

Reimplemented in Slic3r::GUI::GLGizmoCut3D, Slic3r::GUI::GLGizmoMove3D, Slic3r::GUI::GLGizmoRotate3D, Slic3r::GUI::GLGizmoRotate, and Slic3r::GUI::GLGizmoScale3D.

{ return ""; }

Referenced by Slic3r::GUI::GLGizmosManager::get_tooltip().

Here is the caller graph for this function:

GizmoImguiBegin()

bool Slic3r::GUI::GLGizmoBase::GizmoImguiBegin ( const std::string & name, int flags )

protectedinherited

{
    return m_imgui->begin(name, flags);
}

References m_imgui.

Referenced by Slic3r::GUI::GLGizmoAssembly::on_render_input_window(), Slic3r::GUI::GLGizmoBrimEars::on_render_input_window(), Slic3r::GUI::GLGizmoCut3D::on_render_input_window(), Slic3r::GUI::GLGizmoEmboss::on_render_input_window(), Slic3r::GUI::GLGizmoFdmSupports::on_render_input_window(), Slic3r::GUI::GLGizmoFuzzySkin::on_render_input_window(), Slic3r::GUI::GLGizmoMeasure::on_render_input_window(), Slic3r::GUI::GLGizmoMeshBoolean::on_render_input_window(), Slic3r::GUI::GLGizmoMmuSegmentation::on_render_input_window(), Slic3r::GUI::GLGizmoSeam::on_render_input_window(), Slic3r::GUI::GLGizmoSVG::on_render_input_window(), and Slic3r::GUI::GLGizmoTextureDisplacement::on_render_input_window().

Here is the caller graph for this function:

GizmoImguiEnd()

void Slic3r::GUI::GLGizmoBase::GizmoImguiEnd ( )

protectedinherited

{
    last_input_window_width = ImGui::GetWindowWidth();
    m_imgui->end();
}

References last_input_window_width, and m_imgui.

Referenced by Slic3r::GUI::GLGizmoAssembly::on_render_input_window(), Slic3r::GUI::GLGizmoBrimEars::on_render_input_window(), Slic3r::GUI::GLGizmoCut3D::on_render_input_window(), Slic3r::GUI::GLGizmoEmboss::on_render_input_window(), Slic3r::GUI::GLGizmoFdmSupports::on_render_input_window(), Slic3r::GUI::GLGizmoFuzzySkin::on_render_input_window(), Slic3r::GUI::GLGizmoMeasure::on_render_input_window(), Slic3r::GUI::GLGizmoMeshBoolean::on_render_input_window(), Slic3r::GUI::GLGizmoMmuSegmentation::on_render_input_window(), Slic3r::GUI::GLGizmoSeam::on_render_input_window(), and Slic3r::GUI::GLGizmoSVG::on_render_input_window().

Here is the caller graph for this function:

GizmoImguiSetNextWIndowPos() [1/2]

void Slic3r::GUI::GLGizmoBase::GizmoImguiSetNextWIndowPos ( float & x, float y, float w, float h, int flag, float pivot_x = 0.0f, float pivot_y = 0.0f )

protectedinherited

{
    if (abs(w) > 0.01f) {
        if (x + w > m_parent.get_canvas_size().get_width()) {
            if (w > m_parent.get_canvas_size().get_width()) {
                x = 0;
            } else {
                x = m_parent.get_canvas_size().get_width() - w;
            }
        }
    }
 
    m_imgui->set_next_window_pos(x, y, flag, pivot_x, pivot_y);
}

References m_imgui, and m_parent.

GizmoImguiSetNextWIndowPos() [2/2]

void Slic3r::GUI::GLGizmoBase::GizmoImguiSetNextWIndowPos ( float & x, float y, int flag, float pivot_x = 0.0f, float pivot_y = 0.0f )

protectedinherited

{
    GizmoImguiSetNextWIndowPos(x, y, last_input_window_width, 0, flag, pivot_x, pivot_y);
}

References GizmoImguiSetNextWIndowPos(), and last_input_window_width.

Referenced by GizmoImguiSetNextWIndowPos(), Slic3r::GUI::GLGizmoAssembly::on_render_input_window(), Slic3r::GUI::GLGizmoBrimEars::on_render_input_window(), Slic3r::GUI::GLGizmoCut3D::on_render_input_window(), Slic3r::GUI::GLGizmoEmboss::on_render_input_window(), Slic3r::GUI::GLGizmoFdmSupports::on_render_input_window(), Slic3r::GUI::GLGizmoFuzzySkin::on_render_input_window(), Slic3r::GUI::GLGizmoMeasure::on_render_input_window(), Slic3r::GUI::GLGizmoMeshBoolean::on_render_input_window(), Slic3r::GUI::GLGizmoMmuSegmentation::on_render_input_window(), Slic3r::GUI::GLGizmoSeam::on_render_input_window(), Slic3r::GUI::GLGizmoSVG::on_render_input_window(), and Slic3r::GUI::GLGizmoTextureDisplacement::on_render_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

init()

bool Slic3r::GUI::GLGizmoBase::init ( )

inlineinherited

{ return on_init(); }

References on_init().

Here is the call graph for this function:

is_activable()

bool Slic3r::GUI::GLGizmoBase::is_activable ( ) const

inlineinherited

{ return on_is_activable(); }

References on_is_activable().

Referenced by Slic3r::GUI::GLGizmosManager::activate_gizmo(), Slic3r::GUI::GLGizmosManager::do_render_overlay(), Slic3r::GUI::GLGizmoEmboss::init_create(), and Slic3r::GUI::GLGizmosManager::update_hover_state().

Here is the call graph for this function:

Here is the caller graph for this function:

is_dragging()

bool Slic3r::GUI::GLGizmoBase::is_dragging ( ) const

inlineinherited

{ return m_dragging; }

References m_dragging.

Referenced by Slic3r::GUI::GLGizmoCut3D::gizmo_event(), Slic3r::GUI::GLGizmoEmboss::on_mouse_for_translate(), and Slic3r::GUI::GLGizmoSVG::on_mouse_for_translate().

Here is the caller graph for this function:

is_in_editing_mode()

virtual bool Slic3r::GUI::GLGizmoBase::is_in_editing_mode ( ) const

inlinevirtualinherited

Reimplemented in Slic3r::GUI::GLGizmoCut3D.

{ return false; }

Referenced by Slic3r::GUI::GLGizmosManager::on_key().

Here is the caller graph for this function:

is_selectable()

bool Slic3r::GUI::GLGizmoBase::is_selectable ( ) const

inlineinherited

{ return on_is_selectable(); }

References on_is_selectable().

Here is the call graph for this function:

is_selection_rectangle_dragging()

virtual bool Slic3r::GUI::GLGizmoBase::is_selection_rectangle_dragging ( ) const

inlinevirtualinherited

Reimplemented in Slic3r::GUI::GLGizmoBrimEars, and Slic3r::GUI::GLGizmoCut3D.

{ return false; }

is_svg()

bool GLGizmoSVG::is_svg ( const ModelVolume & volume )

static

Check whether volume has emboss data.

Parameters

volume

Pointer to volume

Returns

True when constain emboss data otherwise False

                                                 {
    return volume.emboss_shape.has_value() && volume.emboss_shape->svg_file.has_value();
}

References Slic3r::ModelVolume::emboss_shape.

Referenced by set_volume_by_selection().

Here is the caller graph for this function:

is_svg_object()

bool GLGizmoSVG::is_svg_object ( const ModelVolume & volume )

static

Check whether volume is object containing only emboss volume.

Parameters

volume

Pointer to volume

Returns

True when object otherwise False

                                                        {
    if (!volume.emboss_shape.has_value()) return false;
    if (volume.type() != ModelVolumeType::MODEL_PART) return false;
    for (const ModelVolume *v : volume.get_object()->volumes) {
        if (v->id() == volume.id()) continue;
        if (v->type() == ModelVolumeType::MODEL_PART) return false;
    }
    return true;
}

References Slic3r::ModelVolume::emboss_shape, Slic3r::ModelVolume::get_object(), Slic3r::ObjectBase::id(), Slic3r::MODEL_PART, Slic3r::ModelVolume::type(), and Slic3r::ModelObject::volumes.

Here is the call graph for this function:

load()

void Slic3r::GUI::GLGizmoBase::load ( cereal::BinaryInputArchive & ar )

inlineinherited

{ m_state = On; on_load(ar); }

References m_state, On, and on_load().

Here is the call graph for this function:

load_render_colors()

void Slic3r::GUI::GLGizmoBase::load_render_colors ( )

staticinherited

{
    RenderColor::colors[RenderCol_Grabber_X]           = ImGuiWrapper::to_ImVec4(GLGizmoBase::AXES_COLOR[0]);
    RenderColor::colors[RenderCol_Grabber_Y]           = ImGuiWrapper::to_ImVec4(GLGizmoBase::AXES_COLOR[1]);
    RenderColor::colors[RenderCol_Grabber_Z]           = ImGuiWrapper::to_ImVec4(GLGizmoBase::AXES_COLOR[2]);
    RenderColor::colors[RenderCol_Flatten_Plane]       = ImGuiWrapper::to_ImVec4(GLGizmoBase::FLATTEN_COLOR);
    RenderColor::colors[RenderCol_Flatten_Plane_Hover] = ImGuiWrapper::to_ImVec4(GLGizmoBase::FLATTEN_HOVER_COLOR);
}

References AXES_COLOR, Slic3r::RenderColor::colors, FLATTEN_COLOR, FLATTEN_HOVER_COLOR, RenderCol_Flatten_Plane, RenderCol_Flatten_Plane_Hover, RenderCol_Grabber_X, RenderCol_Grabber_Y, RenderCol_Grabber_Z, and Slic3r::GUI::ImGuiWrapper::to_ImVec4().

Referenced by Slic3r::GUI::GLCanvas3D::init().

Here is the call graph for this function:

Here is the caller graph for this function:

on_change_color_mode()

virtual void Slic3r::GUI::GLGizmoBase::on_change_color_mode ( bool is_dark )

inlinevirtualinherited

{  m_is_dark_mode = is_dark; }

References is_dark(), and m_is_dark_mode.

Here is the call graph for this function:

on_disable_grabber()

void Slic3r::GUI::GLGizmoSVG::on_disable_grabber ( unsigned int id )

inlineoverrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

{ m_rotate_gizmo.disable_grabber(); }

References m_rotate_gizmo.

on_dragging()

void GLGizmoSVG::on_dragging ( const UpdateData & data )

overrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

{ m_rotate_gizmo.dragging(data); }

References m_rotate_gizmo.

on_enable_grabber()

void Slic3r::GUI::GLGizmoSVG::on_enable_grabber ( unsigned int id )

inlineoverrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

{ m_rotate_gizmo.enable_grabber(); }

References m_rotate_gizmo.

on_get_name()

std::string GLGizmoSVG::on_get_name ( ) const

overrideprotectedvirtual

Implements Slic3r::GUI::GLGizmoBase.

{ return _u8L("SVG"); }

References _u8L.

Referenced by on_render_input_window().

Here is the caller graph for this function:

on_get_requirements()

virtual CommonGizmosDataID Slic3r::GUI::GLGizmoBase::on_get_requirements ( ) const

inlineprotectedvirtualinherited

Reimplemented in Slic3r::GUI::GLGizmoBrimEars, Slic3r::GUI::GLGizmoCut3D, Slic3r::GUI::GLGizmoFlatten, Slic3r::GUI::GLGizmoMeshBoolean, Slic3r::GUI::GLGizmoPainterBase, and Slic3r::GUI::GLGizmoSimplify.

{ return CommonGizmosDataID(0); }

Referenced by get_requirements().

Here is the caller graph for this function:

on_init()

bool GLGizmoSVG::on_init ( )

overrideprotectedvirtual

Implements Slic3r::GUI::GLGizmoBase.

{
    m_rotate_gizmo.init();
    ColorRGBA gray_color(.6f, .6f, .6f, .3f);
    m_rotate_gizmo.set_highlight_color(gray_color);
    // Set rotation gizmo upwardrotate
    m_rotate_gizmo.set_angle(PI / 2);
    return true;
}

References m_rotate_gizmo, and PI.

on_is_activable()

bool Slic3r::GUI::GLGizmoSVG::on_is_activable ( ) const

inlineoverrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

{ return true; }

on_is_selectable()

bool Slic3r::GUI::GLGizmoSVG::on_is_selectable ( ) const

inlineoverrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

{ return false; }

on_load()

virtual void Slic3r::GUI::GLGizmoBase::on_load ( cereal::BinaryInputArchive & ar )

inlineprotectedvirtualinherited

Reimplemented in Slic3r::GUI::GLGizmoBrimEars, Slic3r::GUI::GLGizmoCut3D, Slic3r::GUI::GLGizmoMeshBoolean, and Slic3r::GUI::GLGizmoPainterBase.

{}

Referenced by load().

Here is the caller graph for this function:

on_mouse()

bool GLGizmoSVG::on_mouse ( const wxMouseEvent & mouse_event )

overrideprotectedvirtual

Rotate by text on dragging rotate grabers.

Parameters

mouse_event

Information about mouse

Returns

Propagete normaly return false.

Reimplemented from Slic3r::GUI::GLGizmoBase.

{
    // not selected volume
    if (m_volume == nullptr ||
        get_model_volume(m_volume_id, m_parent.get_selection().get_model()->objects) == nullptr ||
        !m_volume->emboss_shape.has_value()) return false;
 
    if (on_mouse_for_rotation(mouse_event)) return true;
    if (on_mouse_for_translate(mouse_event)) return true;
 
    return false;
}

References Slic3r::GUI::get_model_volume(), Slic3r::GUI::GLGizmoBase::m_parent, m_volume, m_volume_id, on_mouse_for_rotation(), on_mouse_for_translate(), and Slic3r::GUI::wxMouseEvent.

Here is the call graph for this function:

on_mouse_for_rotation()

bool GLGizmoSVG::on_mouse_for_rotation ( const wxMouseEvent & mouse_event )

private

{
    if (mouse_event.Moving()) return false;
 
    bool used = use_grabbers(mouse_event);
    if (!m_dragging) return used;
 
    if (mouse_event.Dragging())
        dragging_rotate_gizmo(m_rotate_gizmo.get_angle(), m_angle, m_rotate_start_angle, m_parent.get_selection());
    
    return used;
}

References Slic3r::GUI::dragging_rotate_gizmo(), m_angle, Slic3r::GUI::GLGizmoBase::m_dragging, Slic3r::GUI::GLGizmoBase::m_parent, m_rotate_gizmo, m_rotate_start_angle, Slic3r::GUI::GLGizmoBase::use_grabbers(), and Slic3r::GUI::wxMouseEvent.

Referenced by on_mouse().

Here is the call graph for this function:

Here is the caller graph for this function:

on_mouse_for_translate()

bool GLGizmoSVG::on_mouse_for_translate ( const wxMouseEvent & mouse_event )

private

{
    // exist selected volume?
    if (m_volume == nullptr)
        return false;
 
    auto up_limit = m_keep_up ? std::optional<double>(UP_LIMIT) : std::optional<double>{};
    const Camera &camera = wxGetApp().plater()->get_camera();
 
    bool was_dragging = m_surface_drag.has_value();
    bool res = on_mouse_surface_drag(mouse_event, camera, m_surface_drag, m_parent, m_raycast_manager, up_limit);
    bool is_dragging  = m_surface_drag.has_value();
 
    // End with surface dragging?
    if (was_dragging && !is_dragging) {
        // Update surface by new position
        if (m_volume->emboss_shape->projection.use_surface)
            process();
 
        // TODO: Remove it when it will be stable
        // Distance should not change during dragging
        const GLVolume *gl_volume = m_parent.get_selection().get_first_volume();
        m_distance = calc_distance(*gl_volume, m_raycast_manager, m_parent);
 
        // Show correct value of height & depth inside of inputs
        calculate_scale();
    }
 
    // Start with dragging
    else if (!was_dragging && is_dragging) {
        // Cancel job to prevent interuption of dragging (duplicit result)
        if (m_job_cancel != nullptr)
            m_job_cancel->store(true);
    }
 
    // during drag
    else if (was_dragging && is_dragging) {
        // update scale of selected volume --> should be approx the same
        calculate_scale();
 
        // Recalculate angle for GUI
        if (!m_keep_up)
            m_angle = calc_angle(m_parent.get_selection());
    }
    return res;
}

References Slic3r::GUI::calc_angle(), Slic3r::GUI::calc_distance(), calculate_scale(), Slic3r::GUI::GLGizmoBase::is_dragging(), m_angle, m_distance, m_job_cancel, m_keep_up, Slic3r::GUI::GLGizmoBase::m_parent, m_raycast_manager, m_surface_drag, m_volume, Slic3r::GUI::on_mouse_surface_drag(), process(), Slic3r::GUI::UP_LIMIT, and Slic3r::GUI::wxMouseEvent.

Referenced by on_mouse().

Here is the call graph for this function:

Here is the caller graph for this function:

on_register_raycasters_for_picking()

void GLGizmoSVG::on_register_raycasters_for_picking ( )

overrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

                                                   {
    m_rotate_gizmo.register_raycasters_for_picking();
}

References m_rotate_gizmo.

on_render()

void GLGizmoSVG::on_render ( )

overrideprotectedvirtual

Implements Slic3r::GUI::GLGizmoBase.

                           {
    if (const Selection &selection = m_parent.get_selection(); 
        selection.volumes_count() != 1 || // only one selected volume
        m_volume == nullptr || // already selected volume in gizmo
        get_model_volume(m_volume_id, selection.get_model()->objects) == nullptr) // still exist model
        return;
 
    bool is_surface_dragging = m_surface_drag.has_value();
    bool is_parent_dragging = m_parent.is_mouse_dragging();
    // Do NOT render rotation grabbers when dragging object
    bool is_rotate_by_grabbers = m_dragging;
    if (is_rotate_by_grabbers || 
        (!is_surface_dragging && !is_parent_dragging)) {
        glsafe(::glClear(GL_DEPTH_BUFFER_BIT));
        m_rotate_gizmo.render();
    }
}

References Slic3r::GUI::get_model_volume(), GL_DEPTH_BUFFER_BIT, glClear, glsafe, Slic3r::GUI::GLGizmoBase::m_dragging, Slic3r::GUI::GLGizmoBase::m_parent, m_rotate_gizmo, m_surface_drag, m_volume, and m_volume_id.

Here is the call graph for this function:

on_render_input_window()

void GLGizmoSVG::on_render_input_window ( float x, float y, float bottom_limit )

overrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

{
    set_volume_by_selection();
 
    double screen_scale = wxDisplay(wxGetApp().plater()).GetScaleFactor();
 
    // Orca
    ImGuiWrapper::push_toolbar_style(m_parent.get_scale());
    ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(4.0, 5.0) * screen_scale);
    ImGui::PushStyleVar(ImGuiStyleVar_ScrollbarSize, 4.0f * screen_scale);
 
    // Configuration creation
    if (m_gui_cfg == nullptr || // Exist configuration - first run
        m_gui_cfg->screen_scale != screen_scale || // change of DPI
        m_gui_cfg->dark_mode != m_is_dark_mode // change of dark mode
        ) {
        // Create cache for gui offsets
        ::GuiCfg cfg = create_gui_configuration();
        cfg.screen_scale = screen_scale;
        cfg.dark_mode    = m_is_dark_mode;
 
        GuiCfg gui_cfg{std::move(cfg)};
        m_gui_cfg = std::make_unique<const GuiCfg>(std::move(gui_cfg));
 
        m_icons = init_icons(m_icon_manager, *m_gui_cfg); // need regeneration when change resolution(move between monitors)
    }
 
    // Draw origin position of text during dragging
    if (m_surface_drag.has_value()) {
        ImVec2 mouse_pos = ImGui::GetMousePos();
        ImVec2 center(
            mouse_pos.x + m_surface_drag->mouse_offset.x(),
            mouse_pos.y + m_surface_drag->mouse_offset.y());
        ImU32 color = ImGui::GetColorU32(
            m_surface_drag->exist_hit ? 
                ImVec4(1.f, 1.f, 1.f, .75f) : // transparent white
                ImVec4(1.f, .3f, .3f, .75f)
        ); // Warning color
        const float radius = 16.f;
        ImGuiWrapper::draw_cross_hair(center, radius, color);
    }
    
    static float last_y = 0.0f;
    static float last_h = 0.0f;
 
    // adjust window position to avoid overlap the view toolbar
    const float win_h = ImGui::GetWindowHeight();
    y = std::min(y, bottom_limit - win_h);
    GizmoImguiSetNextWIndowPos(x, y, ImGuiCond_Always, 0.0f, 0.0f);
    if (last_h != win_h || last_y != y) {
        // ask canvas for another frame to render the window in the correct position
        m_imgui->set_requires_extra_frame();
        if (last_h != win_h)
            last_h = win_h;
        if (last_y != y)
            last_y = y;
    }
 
    GizmoImguiBegin(on_get_name(), ImGuiWindowFlags_NoMove | ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar);
 
    draw_window();
 
    GizmoImguiEnd();
 
    // Orca
    ImGui::PopStyleVar(2);
    ImGuiWrapper::pop_toolbar_style();
}

References Slic3r::center(), Slic3r::GUI::ImGuiWrapper::draw_cross_hair(), draw_window(), Slic3r::GUI::GLGizmoBase::GizmoImguiBegin(), Slic3r::GUI::GLGizmoBase::GizmoImguiEnd(), Slic3r::GUI::GLGizmoBase::GizmoImguiSetNextWIndowPos(), m_gui_cfg, m_icon_manager, m_icons, Slic3r::GUI::GLGizmoBase::m_imgui, Slic3r::GUI::GLGizmoBase::m_is_dark_mode, Slic3r::GUI::GLGizmoBase::m_parent, m_surface_drag, on_get_name(), Slic3r::GUI::plater(), Slic3r::GUI::ImGuiWrapper::pop_toolbar_style(), Slic3r::GUI::ImGuiWrapper::push_toolbar_style(), and set_volume_by_selection().

Here is the call graph for this function:

on_save()

virtual void Slic3r::GUI::GLGizmoBase::on_save ( cereal::BinaryOutputArchive & ar ) const

inlineprotectedvirtualinherited

Reimplemented in Slic3r::GUI::GLGizmoBrimEars, Slic3r::GUI::GLGizmoCut3D, Slic3r::GUI::GLGizmoMeshBoolean, and Slic3r::GUI::GLGizmoPainterBase.

{}

Referenced by save().

Here is the caller graph for this function:

on_set_hover_id()

void Slic3r::GUI::GLGizmoSVG::on_set_hover_id ( )

inlineoverrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

{ m_rotate_gizmo.set_hover_id(m_hover_id); }

References Slic3r::GUI::GLGizmoBase::m_hover_id, and m_rotate_gizmo.

on_set_state()

void GLGizmoSVG::on_set_state ( )

overrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

{
    // enable / disable bed from picking
    // Rotation gizmo must work through bed
    m_parent.set_raycaster_gizmos_on_top(GLGizmoBase::m_state == GLGizmoBase::On);
 
    m_rotate_gizmo.set_state(GLGizmoBase::m_state);
 
    // Closing gizmo. e.g. selecting another one
    if (GLGizmoBase::m_state == GLGizmoBase::Off) {
        reset_volume();
    } else if (GLGizmoBase::m_state == GLGizmoBase::On) {
        // Try(when exist) set text configuration by volume 
        set_volume_by_selection();
    }
}

References Slic3r::GUI::GLGizmoBase::m_parent, m_rotate_gizmo, Slic3r::GUI::GLGizmoBase::m_state, Slic3r::GUI::GLGizmoBase::Off, Slic3r::GUI::GLGizmoBase::On, reset_volume(), and set_volume_by_selection().

Here is the call graph for this function:

on_start_dragging()

void GLGizmoSVG::on_start_dragging ( )

overrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

{ m_rotate_gizmo.start_dragging(); }

References m_rotate_gizmo.

on_stop_dragging()

void GLGizmoSVG::on_stop_dragging ( )

overrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

{
    m_rotate_gizmo.stop_dragging();
 
    // TODO: when start second rotatiton previous rotation rotate draggers
    // This is fast fix for second try to rotate
    // When fixing, move grabber above text (not on side)
    m_rotate_gizmo.set_angle(PI/2);
 
    // apply rotation
    // TRN This is an item label in the undo-redo stack.
    m_parent.do_rotate(rotation_snapshot_name);
    m_rotate_start_angle.reset();
    volume_transformation_changed();
 
    // recalculate for surface cut
    if (m_volume != nullptr && 
        m_volume->emboss_shape.has_value() &&
        m_volume->emboss_shape->projection.use_surface)
        process();
}

References Slic3r::GUI::GLGizmoBase::m_parent, m_rotate_gizmo, m_rotate_start_angle, m_volume, PI, process(), and volume_transformation_changed().

Here is the call graph for this function:

on_unregister_raycasters_for_picking()

void GLGizmoSVG::on_unregister_raycasters_for_picking ( )

overrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

                                                     {
    m_rotate_gizmo.unregister_raycasters_for_picking();
}

References m_rotate_gizmo.

process()

bool GLGizmoSVG::process ( bool make_snapshot = true )

private

                                           {
    // no volume is selected -> selection from right panel
    assert(m_volume != nullptr);
    if (m_volume == nullptr) 
        return false;
    
    assert(m_volume->emboss_shape.has_value());
    if (!m_volume->emboss_shape.has_value())
        return false;
 
    // Cancel previous Job, when it is in process
    // worker.cancel(); --> Use less in this case I want cancel only previous EmbossJob no other jobs
    // Cancel only EmbossUpdateJob no others
    if (m_job_cancel != nullptr)
        m_job_cancel->store(true);
    // create new shared ptr to cancel new job
    m_job_cancel = std::make_shared<std::atomic<bool>>(false);
 
    EmbossShape shape = m_volume_shape; // copy
    auto base = std::make_unique<DataBase>(m_volume->name, m_job_cancel, std::move(shape));
    base->is_outside = m_volume->type() == ModelVolumeType::MODEL_PART;
    DataUpdate data{std::move(base), m_volume_id, make_snapshot};
    return start_update_volume(std::move(data), *m_volume, m_parent.get_selection(), m_raycast_manager);    
}

References m_job_cancel, Slic3r::GUI::GLGizmoBase::m_parent, m_raycast_manager, m_volume, m_volume_id, m_volume_shape, Slic3r::MODEL_PART, and Slic3r::GUI::Emboss::start_update_volume().

Referenced by draw_depth(), draw_filename(), draw_mirroring(), draw_model_type(), draw_rotation(), draw_size(), draw_use_surface(), on_mouse_for_translate(), on_stop_dragging(), and volume_transformation_changed().

Here is the call graph for this function:

Here is the caller graph for this function:

register_grabbers_for_picking()

void Slic3r::GUI::GLGizmoBase::register_grabbers_for_picking ( )

protectedinherited

{
    for (size_t i = 0; i < m_grabbers.size(); ++i) {
        m_grabbers[i].register_raycasters_for_picking((m_group_id >= 0) ? m_group_id : i);
    }
}

References m_grabbers, and m_group_id.

Referenced by register_raycasters_for_picking().

Here is the caller graph for this function:

register_raycasters_for_picking()

void Slic3r::GUI::GLGizmoBase::register_raycasters_for_picking ( )

inlineinherited

{ register_grabbers_for_picking(); on_register_raycasters_for_picking(); }

References on_register_raycasters_for_picking(), and register_grabbers_for_picking().

Referenced by Slic3r::GUI::GLGizmosManager::activate_gizmo(), and Slic3r::GUI::GLCanvas3D::reload_scene().

Here is the call graph for this function:

Here is the caller graph for this function:

render()

void Slic3r::GUI::GLGizmoBase::render ( )

inlineinherited

{ on_render(); }

References on_render().

Here is the call graph for this function:

render_combo()

bool Slic3r::GUI::GLGizmoBase::render_combo ( const std::string & label, const std::vector< std::string > & lines, int & selection_idx, float label_width, float item_width )

protectedinherited

{
    ImGuiWrapper::push_combo_style(m_parent.get_scale());
    ImGui::AlignTextToFramePadding();
    m_imgui->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;
 
    //if (is_changed) update_connector_shape();
    ImGuiWrapper::pop_combo_style();
 
    return is_changed;
}

References m_imgui, m_parent, Slic3r::GUI::ImGuiWrapper::pop_combo_style(), and Slic3r::GUI::ImGuiWrapper::push_combo_style().

Referenced by Slic3r::GUI::GLGizmoAssembly::render_assembly_mode_combo(), and Slic3r::GUI::GLGizmoCut3D::render_connectors_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

render_cross_mark()

void Slic3r::GUI::GLGizmoBase::render_cross_mark ( const Vec3f & target, bool is_single = false )

protectedinherited

{
    const float half_length = 4.0f;
 
    // ORCA: OpenGL Core Profile
#if !SLIC3R_OPENGL_ES
    if (!OpenGLManager::get_gl_info().is_core_profile())
        glsafe(::glLineWidth(2.0f));
#endif // !SLIC3R_OPENGL_ES
 
    auto render_line = [](const Vec3f& p1, const Vec3f& p2, const ColorRGBA& color) {
        GLModel::Geometry init_data;
        init_data.format = {GLModel::Geometry::EPrimitiveType::Lines, GLModel::Geometry::EVertexLayout::P3};
        init_data.color  = color;
        init_data.reserve_vertices(2);
        init_data.reserve_indices(2);
 
        // vertices
        init_data.add_vertex(p1);
        init_data.add_vertex(p2);
 
        // indices
        init_data.add_line(0, 1);
 
        GLModel model;
        model.init_from(std::move(init_data));
        model.render();
    };
 
    // draw line for x axis
    if (!is_single) {
        render_line(
            {target(0) - half_length, target(1), target(2)}, 
            {target(0) + half_length, target(1), target(2)},
            ColorRGBA::X()); // ORCA match axis colors
    }
    else {
        render_line(
            {target(0), target(1), target(2)}, 
            {target(0) + half_length, target(1), target(2)},
            ColorRGBA::X()); // ORCA match axis colors
    }
    // draw line for y axis
    if (!is_single) {
        render_line(
            {target(0), target(1) - half_length, target(2)}, 
            {target(0), target(1) + half_length, target(2)},
            ColorRGBA::Y()); // ORCA match axis colors
    } else {
        render_line(
            {target(0), target(1), target(2)}, 
            {target(0), target(1) + half_length, target(2)},
            ColorRGBA::Y()); // ORCA match axis colors
    }
    // draw line for z axis
    if (!is_single) {
        render_line(
            {target(0), target(1), target(2) - half_length}, 
            {target(0), target(1), target(2) + half_length},
            ColorRGBA::Z()); // ORCA match axis colors
    } else {
        render_line(
            {target(0), target(1), target(2)}, 
            {target(0), target(1), target(2) + half_length},
            ColorRGBA::Z()); // ORCA match axis colors
    }
}

References Slic3r::GUI::GLModel::Geometry::add_line(), Slic3r::GUI::GLModel::Geometry::add_vertex(), Slic3r::GUI::GLModel::Geometry::color, Slic3r::GUI::GLModel::Geometry::format, Slic3r::GUI::OpenGLManager::get_gl_info(), glLineWidth, glsafe, Slic3r::GUI::GLModel::init_from(), Slic3r::GUI::GLModel::Geometry::Lines, Slic3r::GUI::GLModel::Geometry::P3, Slic3r::GUI::GLModel::render(), Slic3r::GUI::GLModel::Geometry::reserve_indices(), Slic3r::GUI::GLModel::Geometry::reserve_vertices(), Slic3r::ColorRGBA::X(), Slic3r::ColorRGBA::Y(), and Slic3r::ColorRGBA::Z().

Referenced by Slic3r::GUI::GLGizmoMove3D::on_render().

Here is the call graph for this function:

Here is the caller graph for this function:

render_follows_cursor()

virtual bool Slic3r::GUI::GLGizmoBase::render_follows_cursor ( ) const

inlinevirtualinherited

Reimplemented in Slic3r::GUI::GLGizmoBrimEars, Slic3r::GUI::GLGizmoMeasure, and Slic3r::GUI::GLGizmoPainterBase.

{ return false; }

Referenced by Slic3r::GUI::GLCanvas3D::_is_scene_cacheable().

Here is the caller graph for this function:

render_grabbers() [1/3]

void Slic3r::GUI::GLGizmoBase::render_grabbers ( const BoundingBoxf3 & box ) const

protectedinherited

{
#if ENABLE_FIXED_GRABBER
    render_grabbers((float)(GLGizmoBase::Grabber::FixedGrabberSize));
#else
    render_grabbers((float)((box.size().x() + box.size().y() + box.size().z()) / 3.0));
#endif
}

References Slic3r::GUI::GLGizmoBase::Grabber::FixedGrabberSize, render_grabbers(), and Slic3r::BoundingBox3Base< PointType >::size().

Referenced by Slic3r::GUI::GLGizmoMove3D::on_render(), Slic3r::GUI::GLGizmoScale3D::on_render(), Slic3r::GUI::GLGizmoRotate::render_grabber(), render_grabbers(), and render_grabbers().

Here is the call graph for this function:

Here is the caller graph for this function:

render_grabbers() [2/3]

void Slic3r::GUI::GLGizmoBase::render_grabbers ( float size ) const

protectedinherited

{
    render_grabbers(0, m_grabbers.size() - 1, size, false);
}

References m_grabbers, and render_grabbers().

Here is the call graph for this function:

render_grabbers() [3/3]

void Slic3r::GUI::GLGizmoBase::render_grabbers ( size_t first, size_t last, float size, bool force_hover ) const

protectedinherited

{
    GLShaderProgram* shader = wxGetApp().get_shader("gouraud_light");
    if (shader == nullptr)
        return;
    shader->start_using();
    shader->set_uniform("emission_factor", 0.1f);
    glsafe(::glDisable(GL_CULL_FACE));
    for (size_t i = first; i <= last; ++i) {
        if (m_grabbers[i].enabled)
            m_grabbers[i].render(force_hover ? true : m_hover_id == (int)i, size);
    }
    glsafe(::glEnable(GL_CULL_FACE));
    shader->stop_using();
}

References GL_CULL_FACE, glDisable, glEnable, glsafe, m_grabbers, m_hover_id, Slic3r::GLShaderProgram::set_uniform(), Slic3r::GLShaderProgram::start_using(), and Slic3r::GLShaderProgram::stop_using().

Here is the call graph for this function:

render_input_window()

void Slic3r::GUI::GLGizmoBase::render_input_window ( float x, float y, float bottom_limit )

inherited

{
    on_render_input_window(x, y, bottom_limit);
    if (m_first_input_window_render) {
        // imgui windows that don't have an initial size needs to be processed once to get one
        // and are not rendered in the first frame
        // so, we forces to render another frame the first time the imgui window is shown
        // https://github.com/ocornut/imgui/issues/2949
        m_parent.set_as_dirty();
        m_parent.request_extra_frame();
        m_first_input_window_render = false;
    }
}

References m_first_input_window_render, m_parent, and on_render_input_window().

Here is the call graph for this function:

reset_volume()

void GLGizmoSVG::reset_volume ( )

private

{
    if (m_volume == nullptr)
        return; // already reseted
 
    m_volume = nullptr;
    m_volume_id.id = 0;
    m_volume_shape.shapes_with_ids.clear();
    m_filename_preview.clear();
    m_shape_warnings.clear();
    // delete texture after finish imgui draw
    wxGetApp().plater()->CallAfter([&texture = m_texture]() { delete_texture(texture); });
}

References m_filename_preview, m_shape_warnings, m_texture, m_volume, m_volume_id, and m_volume_shape.

Referenced by close(), on_set_state(), and set_volume_by_selection().

Here is the caller graph for this function:

save()

void Slic3r::GUI::GLGizmoBase::save ( cereal::BinaryOutputArchive & ar ) const

inlineinherited

{ on_save(ar); }

References on_save().

Here is the call graph for this function:

set_common_data_pool()

void Slic3r::GUI::GLGizmoBase::set_common_data_pool ( CommonGizmosDataPool * ptr )

inlineinherited

{ m_c = ptr; }

References m_c.

set_dirty()

void Slic3r::GUI::GLGizmoBase::set_dirty ( )

protectedinherited

                            {
    m_dirty = true;
}

References m_dirty.

Referenced by Slic3r::GUI::GLGizmoCut3D::process_cut_line(), and Slic3r::GUI::GLGizmoSimplify::request_rerender().

Here is the caller graph for this function:

set_hover_id()

void Slic3r::GUI::GLGizmoBase::set_hover_id ( int id )

inherited

{
    // do not change hover id during dragging
    assert(!m_dragging);
 
    // allow empty grabbers when not using grabbers but use hover_id - flatten, rotate
//    if (!m_grabbers.empty() && id >= (int) m_grabbers.size())
//        return;
    
    m_hover_id = id;
    on_set_hover_id();    
}

References m_dragging, m_hover_id, and on_set_hover_id().

Referenced by Slic3r::GUI::GLGizmoRotate3D::on_set_hover_id().

Here is the call graph for this function:

Here is the caller graph for this function:

set_icon_filename()

void Slic3r::GUI::GLGizmoBase::set_icon_filename ( const std::string & filename )

inherited

                                                             {
    m_icon_filename = filename;
}

References m_icon_filename.

set_state()

void Slic3r::GUI::GLGizmoBase::set_state ( EState state )

inlineinherited

{ m_state = state; on_set_state(); }

References m_state, and on_set_state().

Referenced by Slic3r::GUI::GLGizmosManager::activate_gizmo().

Here is the call graph for this function:

Here is the caller graph for this function:

set_volume_by_selection()

void GLGizmoSVG::set_volume_by_selection ( )

private

{
    const Selection &selection = m_parent.get_selection();
    const GLVolume *gl_volume = get_selected_gl_volume(selection);
    if (gl_volume == nullptr)
        return reset_volume();
 
    const ModelObjectPtrs &objects = selection.get_model()->objects;
    ModelVolume *volume =get_model_volume(*gl_volume, objects);
    if (volume == nullptr)
        return reset_volume();
 
    // is same volume as actual selected?
    if (volume->id() == m_volume_id)
        return;
 
    // Do not use focused input value when switch volume(it must swith value)
    if (m_volume != nullptr && 
        m_volume != volume) // when update volume it changed id BUT not pointer
        ImGuiWrapper::left_inputs();
 
    // is valid svg volume?
    if (!is_svg(*volume)) 
        return reset_volume();
 
    // cancel previous job
    if (m_job_cancel != nullptr) {
        m_job_cancel->store(true);
        m_job_cancel = nullptr;
    }
        
    // calculate scale for height and depth inside of scaled object instance
    calculate_scale(); // must be before calculation of tesselation
 
    // checking that exist is inside of function "is_svg"
    EmbossShape &es = *volume->emboss_shape;
    EmbossShape::SvgFile &svg_file = *es.svg_file;
    if (svg_file.image == nullptr) {
        if (init_image(svg_file) == nullptr)
            return reset_volume();
    }
    assert(svg_file.image != nullptr);
    assert(svg_file.image.get() != nullptr);
    const NSVGimage &image = *svg_file.image;
    ExPolygonsWithIds &shape_ids = es.shapes_with_ids;
    if (shape_ids.empty()) {        
        NSVGLineParams params{get_tesselation_tolerance(get_scale_for_tolerance())};
        shape_ids = create_shape_with_ids(image, params);                
    }
 
    reset_volume(); // clear cached data
 
    m_volume = volume;
    m_volume_id = volume->id();
    m_volume_shape = es; // copy
    m_shape_warnings = create_shape_warnings(es, get_scale_for_tolerance());
 
    // Calculate current angle of up vector
    m_angle    = calc_angle(selection);
    m_distance = calc_distance(*gl_volume, m_raycast_manager, m_parent);
    
    m_shape_bb = get_extents(m_volume_shape.shapes_with_ids);
}

References Slic3r::GUI::calc_angle(), Slic3r::GUI::calc_distance(), calculate_scale(), Slic3r::create_shape_with_ids(), Slic3r::ModelVolume::emboss_shape, Slic3r::get_extents(), Slic3r::GUI::Selection::get_model(), Slic3r::GUI::get_model_volume(), get_scale_for_tolerance(), Slic3r::GUI::get_selected_gl_volume(), Slic3r::ObjectBase::id(), Slic3r::EmbossShape::SvgFile::image, Slic3r::init_image(), is_svg(), Slic3r::GUI::ImGuiWrapper::left_inputs(), m_angle, m_distance, m_job_cancel, Slic3r::GUI::GLGizmoBase::m_parent, m_raycast_manager, m_shape_bb, m_shape_warnings, m_volume, m_volume_id, m_volume_shape, Slic3r::Model::objects, reset_volume(), Slic3r::EmbossShape::shapes_with_ids, and Slic3r::EmbossShape::svg_file.

Referenced by data_changed(), on_render_input_window(), and on_set_state().

Here is the call graph for this function:

Here is the caller graph for this function:

shortcut()

std::optional< Shortcut > Slic3r::GUI::GLGizmoBase::shortcut ( ) const

inlineinherited

{ return m_shortcut; }

References m_shortcut.

Referenced by Slic3r::GUI::GLGizmoFdmSupports::on_tool_shortcut(), Slic3r::GUI::GLGizmoMmuSegmentation::on_tool_shortcut(), Slic3r::GUI::GLGizmoPainterBase::on_tool_shortcut(), and Slic3r::GUI::GLGizmoSeam::on_tool_shortcut().

Here is the caller graph for this function:

unregister_grabbers_for_picking()

void Slic3r::GUI::GLGizmoBase::unregister_grabbers_for_picking ( )

protectedinherited

{
    for (size_t i = 0; i < m_grabbers.size(); ++i) {
        m_grabbers[i].unregister_raycasters_for_picking();
    }
}

References m_grabbers.

Referenced by unregister_raycasters_for_picking().

Here is the caller graph for this function:

unregister_raycasters_for_picking()

void Slic3r::GUI::GLGizmoBase::unregister_raycasters_for_picking ( )

inlineinherited

{ unregister_grabbers_for_picking(); on_unregister_raycasters_for_picking(); }

References on_unregister_raycasters_for_picking(), and unregister_grabbers_for_picking().

Referenced by Slic3r::GUI::GLGizmosManager::activate_gizmo(), and Slic3r::GUI::GLCanvas3D::reload_scene().

Here is the call graph for this function:

Here is the caller graph for this function:

update_items_state()

bool Slic3r::GUI::GLGizmoBase::update_items_state ( )

inherited

{
    bool res = m_dirty;
    m_dirty  = false;
    return res;
}

References m_dirty.

update_render_colors()

void Slic3r::GUI::GLGizmoBase::update_render_colors ( )

staticinherited

{
    GLGizmoBase::AXES_COLOR = { {
                                ImGuiWrapper::from_ImVec4(RenderColor::colors[RenderCol_Grabber_X]),
                                ImGuiWrapper::from_ImVec4(RenderColor::colors[RenderCol_Grabber_Y]),
                                ImGuiWrapper::from_ImVec4(RenderColor::colors[RenderCol_Grabber_Z])
                                } };
 
    GLGizmoBase::FLATTEN_COLOR       = ImGuiWrapper::from_ImVec4(RenderColor::colors[RenderCol_Flatten_Plane]);
    GLGizmoBase::FLATTEN_HOVER_COLOR = ImGuiWrapper::from_ImVec4(RenderColor::colors[RenderCol_Flatten_Plane_Hover]);
}

References AXES_COLOR, Slic3r::RenderColor::colors, FLATTEN_COLOR, FLATTEN_HOVER_COLOR, Slic3r::GUI::ImGuiWrapper::from_ImVec4(), RenderCol_Flatten_Plane, RenderCol_Flatten_Plane_Hover, RenderCol_Grabber_X, RenderCol_Grabber_Y, and RenderCol_Grabber_Z.

Referenced by Slic3r::GUI::GLCanvas3D::_render_style_editor().

Here is the call graph for this function:

Here is the caller graph for this function:

use_grabbers()

bool Slic3r::GUI::GLGizmoBase::use_grabbers ( const wxMouseEvent & mouse_event )

protectedinherited

function which Set up m_dragging and call functions on_start_dragging / on_dragging / on_stop_dragging

Parameters

mouse_event

Keep information about mouse click

Returns

same as on_mouse

                                                              {
    bool is_dragging_finished = false;
    if (mouse_event.Moving()) { 
        // it should not happen but for sure
        assert(!m_dragging);
        if (m_dragging) is_dragging_finished = true;
        else return false; 
    } 
 
    if (mouse_event.LeftDown()) {
        Selection &selection = m_parent.get_selection();
        if (!selection.is_empty() && m_hover_id != -1 /* &&
            (m_grabbers.empty() || m_hover_id < static_cast<int>(m_grabbers.size()))*/) {
            selection.setup_cache();
 
            m_dragging = true;
            for (auto &grabber : m_grabbers) grabber.dragging = false;
//            if (!m_grabbers.empty() && m_hover_id < int(m_grabbers.size()))
//                m_grabbers[m_hover_id].dragging = true;
            
            on_start_dragging();
 
            // Let the plater know that the dragging started
            m_parent.post_event(SimpleEvent(EVT_GLCANVAS_MOUSE_DRAGGING_STARTED));
            m_parent.set_as_dirty();
            return true;
        }
    } else if (m_dragging) {
        // when mouse cursor leave window than finish actual dragging operation
        bool is_leaving = mouse_event.Leaving() && !m_parent.has_mouse_capture(); // ORCA keep tracking mouse position while drag active and cursor not in window bounds
        if (mouse_event.Dragging()) {
            Point      mouse_coord(mouse_event.GetX(), mouse_event.GetY());
            auto       ray = m_parent.mouse_ray(mouse_coord);
            UpdateData data(ray, mouse_coord);
 
            on_dragging(data);
 
            wxGetApp().obj_manipul()->set_dirty();
            m_parent.set_as_dirty();
            return true;
        }
        else if (mouse_event.LeftUp() || is_leaving || is_dragging_finished) {
            do_stop_dragging(is_leaving);
            return true;
        }
    }
    return false;
}

References do_stop_dragging(), Slic3r::GUI::Selection::is_empty(), m_dragging, m_grabbers, m_hover_id, m_parent, on_dragging(), on_start_dragging(), Slic3r::GUI::Selection::setup_cache(), and Slic3r::GUI::wxMouseEvent.

Referenced by Slic3r::GUI::GLGizmoBrimEars::on_mouse(), Slic3r::GUI::GLGizmoCut3D::on_mouse(), Slic3r::GUI::GLGizmoMove3D::on_mouse(), Slic3r::GUI::GLGizmoRotate3D::on_mouse(), Slic3r::GUI::GLGizmoRotate::on_mouse(), Slic3r::GUI::GLGizmoScale3D::on_mouse(), Slic3r::GUI::GLGizmoEmboss::on_mouse_for_rotation(), and Slic3r::GUI::GLGizmoSVG::on_mouse_for_rotation().

Here is the call graph for this function:

Here is the caller graph for this function:

volume_transformation_changed()

void GLGizmoSVG::volume_transformation_changed ( )

private

{
    if (m_volume == nullptr || 
        !m_volume->emboss_shape.has_value()) {
        assert(false);
        return;
    }
 
    if (!m_keep_up) {
        // update current style
        m_angle = calc_angle(m_parent.get_selection());
    } else {
        // angle should be the same
        assert(is_approx(m_angle, calc_angle(m_parent.get_selection())));
    }
 
    // Update surface by new position
    if (m_volume->emboss_shape->projection.use_surface) {
        process();
    } else {
        // inform slicing process that model changed
        // SLA supports, processing
        // ensure on bed
        wxGetApp().plater()->changed_object(*m_volume->get_object());
    }
 
    // Show correct value of height & depth inside of inputs
    calculate_scale();
}

References Slic3r::GUI::calc_angle(), calculate_scale(), Slic3r::is_approx(), m_angle, m_keep_up, Slic3r::GUI::GLGizmoBase::m_parent, m_volume, and process().

Referenced by draw_face_the_camera(), draw_mirroring(), and on_stop_dragging().

Here is the call graph for this function:

Here is the caller graph for this function:

wants_enter_leave_snapshots()

bool GLGizmoSVG::wants_enter_leave_snapshots ( ) const

overrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

{ return true; }

Member Data Documentation

AXES_COLOR

std::array< ColorRGBA, 3 > Slic3r::GUI::GLGizmoBase::AXES_COLOR

staticinherited

Initial value:

= {{
    ColorRGBA::X(),
    ColorRGBA::Y(),
    ColorRGBA::Z()
}}

Referenced by Slic3r::GUI::get_color(), load_render_colors(), Slic3r::GUI::GLGizmoRotate3D::on_init(), Slic3r::GUI::GLGizmoMove3D::on_render(), Slic3r::GUI::GLGizmoRotate::on_render(), Slic3r::GUI::GLGizmoScale3D::update_grabbers_data(), and update_render_colors().

AXES_HOVER_COLOR

std::array< ColorRGBA, 3 > Slic3r::GUI::GLGizmoBase::AXES_HOVER_COLOR

staticinherited

Initial value:

= {{
    {ColorRGBA::X().r() * 1.2f, ColorRGBA::X().g() * 1.4f, ColorRGBA::X().b() * 1.4f, 1.0f},
    {ColorRGBA::Y().r() * 1.2f, ColorRGBA::Y().g() * 1.2f, ColorRGBA::Y().b() * 1.2f, 1.0f},
    {ColorRGBA::Z().r() * 1.2f, ColorRGBA::Z().g() * 1.2f, ColorRGBA::Z().b() * 1.2f, 1.0f},
}}

Referenced by Slic3r::GUI::GLGizmoMove3D::on_render(), Slic3r::GUI::GLGizmoRotate::on_render(), and Slic3r::GUI::GLGizmoScale3D::update_grabbers_data().

BASE_ID

const unsigned int Slic3r::GUI::GLGizmoBase::BASE_ID = 255 * 255 * 254

staticinherited

CONSTRAINED_COLOR

ColorRGBA Slic3r::GUI::GLGizmoBase::CONSTRAINED_COLOR = {0.5f, 0.5f, 0.5f, 1.0f}

staticinherited

Referenced by Slic3r::GUI::GLGizmoScale3D::update_grabbers_data().

count

int Slic3r::GUI::GLGizmoBase::count = 0

privateinherited

Referenced by get_count(), Slic3r::GUI::GLGizmoTextureDisplacement::pick_mixes(), Slic3r::GUI::GLGizmoTextureDisplacement::push_uv_pane_state(), Slic3r::GUI::GLGizmoMove3D::render_align_preview(), Slic3r::GUI::GLGizmoTextureDisplacement::render_texture_library_popup(), and Slic3r::GUI::GLGizmoTextureDisplacement::texture_volume_raycaster_index().

DEFAULT_BASE_COLOR

ColorRGBA Slic3r::GUI::GLGizmoBase::DEFAULT_BASE_COLOR = { 0.625f, 0.625f, 0.625f, 1.0f }

staticinherited

DEFAULT_DRAG_COLOR

ColorRGBA Slic3r::GUI::GLGizmoBase::DEFAULT_DRAG_COLOR = { 1.0f, 1.0f, 1.0f, 1.0f }

staticinherited

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

DEFAULT_HIGHLIGHT_COLOR

ColorRGBA Slic3r::GUI::GLGizmoBase::DEFAULT_HIGHLIGHT_COLOR = {1.0f, 0.38f, 0.0f, 1.0f}

staticinherited

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

FLATTEN_COLOR

ColorRGBA Slic3r::GUI::GLGizmoBase::FLATTEN_COLOR = {0.96f, 0.93f, 0.93f, 0.5f}

staticinherited

Referenced by load_render_colors(), Slic3r::GUI::GLGizmoFlatten::on_render(), and update_render_colors().

FLATTEN_HOVER_COLOR

ColorRGBA Slic3r::GUI::GLGizmoBase::FLATTEN_HOVER_COLOR = {1.0f, 1.0f, 1.0f, 0.75f}

staticinherited

Referenced by load_render_colors(), Slic3r::GUI::GLGizmoFlatten::on_render(), and update_render_colors().

GRABBER_ELEMENTS_MAX_COUNT

const unsigned int Slic3r::GUI::GLGizmoBase::GRABBER_ELEMENTS_MAX_COUNT = 7

staticinherited

GRABBER_HOVER_COL

ColorRGBA Slic3r::GUI::GLGizmoBase::GRABBER_HOVER_COL = {0.863f, 0.125f, 0.063f, 1.0f}

staticinherited

GRABBER_NORMAL_COL

ColorRGBA Slic3r::GUI::GLGizmoBase::GRABBER_NORMAL_COL = {1.0f, 1.0f, 1.0f, 1.0f}

staticinherited

GRABBER_UNIFORM_COL

ColorRGBA Slic3r::GUI::GLGizmoBase::GRABBER_UNIFORM_COL = {0, 1.0, 1.0, 1.0f}

staticinherited

Referenced by Slic3r::GUI::GLGizmoScale3D::update_grabbers_data().

GRABBER_UNIFORM_HOVER_COL

ColorRGBA Slic3r::GUI::GLGizmoBase::GRABBER_UNIFORM_HOVER_COL = {0, 0.7, 0.7, 1.0f}

staticinherited

Referenced by Slic3r::GUI::GLGizmoScale3D::update_grabbers_data().

INV_ZOOM

float Slic3r::GUI::GLGizmoBase::INV_ZOOM = 1.0f

staticinherited

Referenced by Slic3r::GUI::GLCanvas3D::_render_current_gizmo(), Slic3r::GUI::get_grabber_mean_size(), Slic3r::GUI::GLGizmoMove3D::on_render(), and Slic3r::GUI::GLGizmoBase::Grabber::render().

last_input_window_width

float Slic3r::GUI::GLGizmoBase::last_input_window_width = 0

protectedinherited

Referenced by GizmoImguiEnd(), and GizmoImguiSetNextWIndowPos().

m_angle

std::optional<float> Slic3r::GUI::GLGizmoSVG::m_angle

private

Referenced by draw_mirroring(), draw_rotation(), on_mouse_for_rotation(), on_mouse_for_translate(), set_volume_by_selection(), and volume_transformation_changed().

m_c

CommonGizmosDataPool* Slic3r::GUI::GLGizmoBase::m_c { nullptr }

protectedinherited

{ nullptr };

Referenced by Slic3r::GUI::GLGizmoTextureDisplacement::apply_projection_frame(), Slic3r::GUI::GLGizmoTextureDisplacement::bake(), Slic3r::GUI::GLGizmoTextureDisplacement::capture_view_projection(), Slic3r::GUI::GLGizmoCut3D::check_and_update_connectors_state(), Slic3r::GUI::GLGizmoBrimEars::data_changed(), Slic3r::GUI::GLGizmoCut3D::data_changed(), Slic3r::GUI::GLGizmoMmuSegmentation::data_changed(), Slic3r::GUI::GLGizmoPainterBase::data_changed(), Slic3r::GUI::GLGizmoCut3D::dragging_connector(), Slic3r::GUI::GLGizmoMeshBoolean::generate_new_volume(), Slic3r::GUI::GLGizmoPainterBase::get_clipping_plane_data(), Slic3r::GUI::GLGizmoPainterBase::get_clipping_plane_in_volume_coordinates(), Slic3r::GUI::GLGizmoBrimEars::get_config_options(), Slic3r::GUI::GLGizmoPainterBase::get_projected_height_range(), Slic3r::GUI::GLGizmoPainterBase::get_projected_mouse_positions(), Slic3r::GUI::GLGizmoFdmSupports::get_selection_support_threshold_angle(), Slic3r::GUI::GLGizmoBrimEars::gizmo_event(), Slic3r::GUI::GLGizmoCut3D::gizmo_event(), Slic3r::GUI::GLGizmoMeshBoolean::gizmo_event(), Slic3r::GUI::GLGizmoPainterBase::gizmo_event(), Slic3r::GUI::GLGizmoCut3D::has_valid_contour(), Slic3r::GUI::GLGizmoSimplify::init_model(), Slic3r::GUI::GLGizmoMmuSegmentation::init_model_triangle_selectors(), Slic3r::GUI::GLGizmoFdmSupports::init_print_instance(), Slic3r::GUI::GLGizmoBrimEars::is_mesh_point_clipped(), Slic3r::GUI::GLGizmoPainterBase::is_mesh_point_clipped(), Slic3r::GUI::GLGizmoCut3D::is_outside_of_cut_contour(), Slic3r::GUI::GLGizmoFlatten::is_plane_update_necessary(), Slic3r::GUI::GLGizmoPainterBase::mesh_trafo_matrices(), Slic3r::GUI::GLGizmoFdmSupports::need_regenerate_support_volumes(), Slic3r::GUI::GLGizmoMeshBoolean::on_get_requirements(), Slic3r::GUI::GLGizmoMeshBoolean::on_load(), Slic3r::GUI::GLGizmoTextureDisplacement::on_mouse_adjust_texture(), Slic3r::GUI::GLGizmoCut3D::on_register_raycasters_for_picking(), Slic3r::GUI::GLGizmoBrimEars::on_render(), Slic3r::GUI::GLGizmoMeshBoolean::on_render(), Slic3r::GUI::GLGizmoBrimEars::on_render_input_window(), Slic3r::GUI::GLGizmoCut3D::on_render_input_window(), Slic3r::GUI::GLGizmoFdmSupports::on_render_input_window(), Slic3r::GUI::GLGizmoFuzzySkin::on_render_input_window(), Slic3r::GUI::GLGizmoMmuSegmentation::on_render_input_window(), Slic3r::GUI::GLGizmoSeam::on_render_input_window(), Slic3r::GUI::GLGizmoTextureDisplacement::on_render_input_window(), Slic3r::GUI::GLGizmoCut3D::on_set_state(), Slic3r::GUI::GLGizmoFdmSupports::on_set_state(), Slic3r::GUI::GLGizmoMmuSegmentation::on_set_state(), Slic3r::GUI::GLGizmoSeam::on_set_state(), Slic3r::GUI::GLGizmoTextureDisplacement::preview_part(), Slic3r::GUI::GLGizmoCut3D::process_contours(), Slic3r::GUI::GLGizmoCut3D::process_selection_rectangle(), Slic3r::GUI::GLGizmoCut3D::put_connectors_on_cut_plane(), Slic3r::GUI::GLGizmoTextureDisplacement::queue_prepare(), Slic3r::GUI::GLGizmoBrimEars::reload_cache(), Slic3r::GUI::GLGizmoMmuSegmentation::remap_filament_assignments(), Slic3r::GUI::GLGizmoTextureDisplacement::render_adjust_texture_gizmo(), Slic3r::GUI::GLGizmoCut3D::render_clipper_cut(), Slic3r::GUI::GLGizmoCut3D::render_connectors(), Slic3r::GUI::GLGizmoCut3D::render_debug_input_window(), Slic3r::GUI::GLGizmoPainterBase::render_follows_cursor(), Slic3r::GUI::GLGizmoTextureDisplacement::render_island_overlay(), Slic3r::GUI::GLGizmoTextureDisplacement::render_paint_overlay(), Slic3r::GUI::GLGizmoTextureDisplacement::render_painted_colors(), Slic3r::GUI::GLGizmoFdmSupports::render_painter_gizmo(), Slic3r::GUI::GLGizmoFuzzySkin::render_painter_gizmo(), Slic3r::GUI::GLGizmoMmuSegmentation::render_painter_gizmo(), Slic3r::GUI::GLGizmoSeam::render_painter_gizmo(), Slic3r::GUI::GLGizmoTextureDisplacement::render_painter_gizmo(), Slic3r::GUI::GLGizmoBrimEars::render_points(), Slic3r::GUI::GLGizmoTextureDisplacement::render_preview_mesh(), Slic3r::GUI::GLGizmoTextureDisplacement::render_seam_overlay(), Slic3r::GUI::GLGizmoTextureDisplacement::render_shaded_preview_mesh(), Slic3r::GUI::GLGizmoTextureDisplacement::render_subdivide_preview(), Slic3r::GUI::GLGizmoPainterBase::render_triangles(), Slic3r::GUI::GLGizmoTextureDisplacement::render_uvcheck_mesh(), Slic3r::GUI::GLGizmoTextureDisplacement::render_wireframe_overlay(), Slic3r::GUI::GLGizmoCut3D::reset_connectors(), Slic3r::GUI::GLGizmoFdmSupports::run_thread(), Slic3r::GUI::GLGizmoTextureDisplacement::seam_edge_at(), Slic3r::GUI::GLGizmoTextureDisplacement::seam_vertex_at(), Slic3r::GUI::GLGizmoFdmSupports::select_facets_by_angle(), Slic3r::GUI::GLGizmoTextureDisplacement::select_visible_faces(), Slic3r::GUI::GLGizmoTextureDisplacement::select_whole_model(), Slic3r::GUI::GLGizmoBrimEars::set_brim_data(), set_common_data_pool(), Slic3r::GUI::GLGizmoCut3D::set_connectors_editing(), Slic3r::GUI::GLGizmoTextureDisplacement::shaded_preview_ready(), Slic3r::GUI::GLGizmoTextureDisplacement::smooth_model(), Slic3r::GUI::GLGizmoTextureDisplacement::subdivide_model(), Slic3r::GUI::GLGizmoTextureDisplacement::swap_layer_slots(), Slic3r::GUI::GLGizmoCut3D::switch_to_mode(), Slic3r::GUI::GLGizmoTextureDisplacement::texture_parts(), Slic3r::GUI::GLGizmoTextureDisplacement::texture_volume(), Slic3r::GUI::GLGizmoTextureDisplacement::texture_volume_raycaster_index(), Slic3r::GUI::GLGizmoCut3D::unproject_on_cut_plane(), Slic3r::GUI::GLGizmoBrimEars::unproject_on_mesh(), Slic3r::GUI::GLGizmoBrimEars::unproject_on_mesh2(), Slic3r::GUI::GLGizmoCut3D::update_bb(), Slic3r::GUI::GLGizmoCut3D::update_clipper(), Slic3r::GUI::GLGizmoFdmSupports::update_from_model_object(), Slic3r::GUI::GLGizmoFuzzySkin::update_from_model_object(), Slic3r::GUI::GLGizmoSeam::update_from_model_object(), Slic3r::GUI::GLGizmoTextureDisplacement::update_from_model_object(), Slic3r::GUI::GLGizmoBrimEars::update_model_object(), Slic3r::GUI::GLGizmoFdmSupports::update_model_object(), Slic3r::GUI::GLGizmoFuzzySkin::update_model_object(), Slic3r::GUI::GLGizmoMmuSegmentation::update_model_object(), Slic3r::GUI::GLGizmoSeam::update_model_object(), Slic3r::GUI::GLGizmoTextureDisplacement::update_model_object(), Slic3r::GUI::GLGizmoFlatten::update_planes(), Slic3r::GUI::GLGizmoPainterBase::update_raycast_cache(), and Slic3r::GUI::GLGizmoCut3D::update_raycasters_for_picking_transform().

m_dirty

bool Slic3r::GUI::GLGizmoBase::m_dirty { false }

privateinherited

{ false };

Referenced by set_dirty(), and update_items_state().

m_distance

std::optional<float> Slic3r::GUI::GLGizmoSVG::m_distance

private

Referenced by draw_distance(), on_mouse_for_translate(), and set_volume_by_selection().

m_dragging

bool Slic3r::GUI::GLGizmoBase::m_dragging { false }

protectedinherited

{ false };

Referenced by do_stop_dragging(), Slic3r::GUI::GLGizmoCut3D::get_tooltip(), is_dragging(), Slic3r::GUI::GLGizmoRotate3D::on_mouse(), Slic3r::GUI::GLGizmoScale3D::on_mouse(), Slic3r::GUI::GLGizmoEmboss::on_mouse_for_rotation(), Slic3r::GUI::GLGizmoSVG::on_mouse_for_rotation(), Slic3r::GUI::GLGizmoEmboss::on_render(), Slic3r::GUI::GLGizmoSVG::on_render(), Slic3r::GUI::GLGizmoCut3D::render_cut_plane_grabbers(), Slic3r::GUI::GLGizmoCut3D::render_rotation_snapping(), Slic3r::GUI::GLGizmoCut3D::reset_cut_by_contours(), set_hover_id(), and use_grabbers().

m_filename_preview

std::string Slic3r::GUI::GLGizmoSVG::m_filename_preview

private

Referenced by draw_filename(), and reset_volume().

m_first_input_window_render

bool Slic3r::GUI::GLGizmoBase::m_first_input_window_render { true }

protectedinherited

{ true };

Referenced by render_input_window().

m_grabbers

std::vector<Grabber> Slic3r::GUI::GLGizmoBase::m_grabbers

mutableprotectedinherited

Referenced by Slic3r::GUI::GLGizmoMove3D::data_changed(), Slic3r::GUI::GLGizmoScale3D::data_changed(), Slic3r::GUI::GLGizmoRotate::disable_grabber(), do_stop_dragging(), Slic3r::GUI::GLGizmoRotate::enable_grabber(), Slic3r::GUI::GLGizmoScale3D::enable_ununiversal_scale(), Slic3r::GUI::GLGizmoMove3D::get_tooltip(), Slic3r::GUI::GLGizmoRotate::get_tooltip(), Slic3r::GUI::GLGizmoScale3D::get_tooltip(), Slic3r::GUI::GLGizmoCut3D::on_init(), Slic3r::GUI::GLGizmoMove3D::on_init(), Slic3r::GUI::GLGizmoRotate::on_init(), Slic3r::GUI::GLGizmoScale3D::on_init(), Slic3r::GUI::GLGizmoMove3D::on_render(), Slic3r::GUI::GLGizmoRotate::on_render(), Slic3r::GUI::GLGizmoScale3D::on_render(), Slic3r::GUI::GLGizmoMove3D::on_start_dragging(), Slic3r::GUI::GLGizmoScale3D::on_start_dragging(), Slic3r::GUI::GLGizmoBrimEars::on_unregister_raycasters_for_picking(), register_grabbers_for_picking(), Slic3r::GUI::GLGizmoRotate::render_grabber(), Slic3r::GUI::GLGizmoRotate::render_grabber_connection(), render_grabbers(), render_grabbers(), Slic3r::GUI::GLGizmoScale3D::render_grabbers_connection(), Slic3r::GUI::GLGizmoBrimEars::render_points(), Slic3r::GUI::GLGizmoRotate::start_dragging(), Slic3r::GUI::GLGizmoRotate::stop_dragging(), unregister_grabbers_for_picking(), Slic3r::GUI::GLGizmoScale3D::update_grabbers_data(), Slic3r::GUI::GLGizmoBrimEars::update_raycasters(), and use_grabbers().

m_group_id

int Slic3r::GUI::GLGizmoBase::m_group_id

protectedinherited

Referenced by GLGizmoBase(), Slic3r::GUI::GLGizmoRotate::GLGizmoRotate(), register_grabbers_for_picking(), and Slic3r::GUI::GLGizmoRotate::set_group_id().

m_gui_cfg

std::unique_ptr<const GuiCfg> Slic3r::GUI::GLGizmoSVG::m_gui_cfg

private

Referenced by GLGizmoSVG(), draw_depth(), draw_distance(), draw_filename(), draw_mirroring(), draw_model_type(), draw_preview(), draw_rotation(), draw_size(), draw_use_surface(), draw_window(), and on_render_input_window().

m_hover_id

int Slic3r::GUI::GLGizmoBase::m_hover_id { -1 }

protectedinherited

{ -1 };

Referenced by Slic3r::GUI::GLGizmoScale3D::calc_ratio(), Slic3r::GUI::GLGizmoScale3D::do_scale_along_axis(), Slic3r::GUI::GLGizmoScale3D::do_scale_uniform(), Slic3r::GUI::GLGizmoCut3D::dragging_connector(), Slic3r::GUI::GLGizmoCut3D::dragging_grabber_move(), Slic3r::GUI::GLGizmoCut3D::dragging_grabber_rotation(), get_hover_id(), Slic3r::GUI::GLGizmoCut3D::get_tooltip(), Slic3r::GUI::GLGizmoMove3D::get_tooltip(), Slic3r::GUI::GLGizmoRotate::get_tooltip(), Slic3r::GUI::GLGizmoScale3D::get_tooltip(), Slic3r::GUI::GLGizmoBrimEars::gizmo_event(), Slic3r::GUI::GLGizmoCut3D::gizmo_event(), Slic3r::GUI::GLGizmoCut3D::is_selection_changed(), Slic3r::GUI::GLGizmoBrimEars::on_dragging(), Slic3r::GUI::GLGizmoCut3D::on_dragging(), Slic3r::GUI::GLGizmoMove3D::on_dragging(), Slic3r::GUI::GLGizmoRotate3D::on_dragging(), Slic3r::GUI::GLGizmoScale3D::on_dragging(), Slic3r::GUI::GLGizmoCut3D::on_mouse(), Slic3r::GUI::GLGizmoFlatten::on_mouse(), Slic3r::GUI::GLGizmoMeasure::on_mouse(), Slic3r::GUI::GLGizmoFlatten::on_render(), Slic3r::GUI::GLGizmoMeasure::on_render(), Slic3r::GUI::GLGizmoMove3D::on_render(), Slic3r::GUI::GLGizmoRotate3D::on_render(), Slic3r::GUI::GLGizmoRotate::on_render(), Slic3r::GUI::GLGizmoScale3D::on_render(), Slic3r::GUI::GLGizmoBrimEars::on_set_hover_id(), Slic3r::GUI::GLGizmoEmboss::on_set_hover_id(), Slic3r::GUI::GLGizmoRotate3D::on_set_hover_id(), Slic3r::GUI::GLGizmoSVG::on_set_hover_id(), Slic3r::GUI::GLGizmoMeasure::on_set_state(), Slic3r::GUI::GLGizmoBrimEars::on_start_dragging(), Slic3r::GUI::GLGizmoCut3D::on_start_dragging(), Slic3r::GUI::GLGizmoMove3D::on_start_dragging(), Slic3r::GUI::GLGizmoRotate3D::on_start_dragging(), Slic3r::GUI::GLGizmoScale3D::on_start_dragging(), Slic3r::GUI::GLGizmoBrimEars::on_stop_dragging(), Slic3r::GUI::GLGizmoCut3D::on_stop_dragging(), Slic3r::GUI::GLGizmoRotate3D::on_stop_dragging(), Slic3r::GUI::GLGizmoCut3D::render_connectors(), Slic3r::GUI::GLGizmoCut3D::render_cut_plane_grabbers(), Slic3r::GUI::GLGizmoCut3D::render_flip_plane_button(), render_grabbers(), Slic3r::GUI::GLGizmoBrimEars::render_points(), set_hover_id(), Slic3r::GUI::GLGizmoMeasure::show_selection_ui(), Slic3r::GUI::GLGizmoScale3D::update_grabbers_data(), and use_grabbers().

M_ICON_FILENAME

const std::string GLGizmoSVG::M_ICON_FILENAME = "cut.svg"

staticprivate

Referenced by GLGizmoSVG().

m_icon_filename

std::string Slic3r::GUI::GLGizmoBase::m_icon_filename

protectedinherited

Referenced by GLGizmoBase(), get_icon_filename(), and set_icon_filename().

m_icon_manager

IconManager Slic3r::GUI::GLGizmoSVG::m_icon_manager

private

Referenced by on_render_input_window().

m_icons

IconManager::VIcons Slic3r::GUI::GLGizmoSVG::m_icons

private

Referenced by draw_distance(), draw_filename(), draw_mirroring(), draw_rotation(), draw_size(), and on_render_input_window().

m_imgui

ImGuiWrapper* Slic3r::GUI::GLGizmoBase::m_imgui

protectedinherited

Referenced by GLGizmoBase(), Slic3r::GUI::GLGizmoEmboss::GLGizmoEmboss(), Slic3r::GUI::GLGizmoCut3D::add_horizontal_scaled_interval(), Slic3r::GUI::GLGizmoCut3D::add_vertical_scaled_interval(), Slic3r::GUI::GLGizmoSimplify::create_gui_cfg(), Slic3r::GUI::GLGizmoEmboss::draw_advanced(), Slic3r::GUI::GLGizmoEmboss::draw_bold_button(), Slic3r::GUI::GLGizmoEmboss::draw_delete_style_button(), Slic3r::GUI::GLGizmoSVG::draw_depth(), Slic3r::GUI::GLGizmoSVG::draw_distance(), Slic3r::GUI::GLGizmoSVG::draw_filename(), Slic3r::GUI::GLGizmoEmboss::draw_font_list(), Slic3r::GUI::GLGizmoEmboss::draw_font_list_line(), Slic3r::GUI::GLGizmoEmboss::draw_italic_button(), Slic3r::GUI::GLGizmoSVG::draw_mirroring(), Slic3r::GUI::GLGizmoEmboss::draw_model_type(), Slic3r::GUI::GLGizmoSVG::draw_model_type(), Slic3r::GUI::GLGizmoSVG::draw_rotation(), Slic3r::GUI::GLGizmoSVG::draw_size(), Slic3r::GUI::GLGizmoEmboss::draw_style_add_button(), Slic3r::GUI::GLGizmoEmboss::draw_style_list(), Slic3r::GUI::GLGizmoEmboss::draw_style_rename_button(), Slic3r::GUI::GLGizmoEmboss::draw_style_rename_popup(), Slic3r::GUI::GLGizmoEmboss::draw_style_save_as_popup(), Slic3r::GUI::GLGizmoEmboss::draw_style_save_button(), Slic3r::GUI::GLGizmoEmboss::draw_text_input(), Slic3r::GUI::GLGizmoSVG::draw_use_surface(), Slic3r::GUI::GLGizmoEmboss::draw_window(), GizmoImguiBegin(), GizmoImguiEnd(), GizmoImguiSetNextWIndowPos(), Slic3r::GUI::GLGizmoCut3D::init_input_window_data(), Slic3r::GUI::GLGizmoMeasure::on_mouse(), Slic3r::GUI::GLGizmoAssembly::on_render_input_window(), Slic3r::GUI::GLGizmoBrimEars::on_render_input_window(), Slic3r::GUI::GLGizmoEmboss::on_render_input_window(), Slic3r::GUI::GLGizmoFdmSupports::on_render_input_window(), Slic3r::GUI::GLGizmoFuzzySkin::on_render_input_window(), Slic3r::GUI::GLGizmoMeasure::on_render_input_window(), Slic3r::GUI::GLGizmoMeshBoolean::on_render_input_window(), Slic3r::GUI::GLGizmoMmuSegmentation::on_render_input_window(), Slic3r::GUI::GLGizmoMove3D::on_render_input_window(), Slic3r::GUI::GLGizmoRotate3D::on_render_input_window(), Slic3r::GUI::GLGizmoScale3D::on_render_input_window(), Slic3r::GUI::GLGizmoSeam::on_render_input_window(), Slic3r::GUI::GLGizmoSimplify::on_render_input_window(), Slic3r::GUI::GLGizmoSVG::on_render_input_window(), Slic3r::GUI::GLGizmoTextureDisplacement::on_render_input_window(), Slic3r::GUI::GLGizmoTextureDisplacement::panel_tooltip(), Slic3r::GUI::GLGizmoCut3D::render_angle_input(), Slic3r::GUI::GLGizmoCut3D::render_build_size(), Slic3r::GUI::GLGizmoCut3D::render_color_marker(), render_combo(), Slic3r::GUI::GLGizmoCut3D::render_connectors_input_window(), Slic3r::GUI::GLGizmoCut3D::render_cut_mode_combo(), Slic3r::GUI::GLGizmoCut3D::render_cut_plane_input_window(), Slic3r::GUI::GLGizmoCut3D::render_debug_input_window(), Slic3r::GUI::GLGizmoTextureDisplacement::render_debug_stage_panel(), Slic3r::GUI::GLGizmoMeasure::render_dimensioning(), Slic3r::GUI::GLGizmoCut3D::render_double_input(), Slic3r::GUI::GLGizmoMmuSegmentation::render_filament_remap_ui(), Slic3r::GUI::GLGizmoCut3D::render_flip_plane_button(), Slic3r::GUI::GLGizmoCut3D::render_groove_float_input(), Slic3r::GUI::GLGizmoCut3D::render_groove_int_input(), Slic3r::GUI::GLGizmoCut3D::render_groove_two_float_input(), Slic3r::GUI::GLGizmoTextureDisplacement::render_image_adjust_window(), Slic3r::GUI::GLGizmoAssembly::render_input_window_warning(), Slic3r::GUI::GLGizmoCut3D::render_input_window_warning(), Slic3r::GUI::GLGizmoCut3D::render_move_center_input(), Slic3r::GUI::GLGizmoCut3D::render_reset_button(), Slic3r::GUI::GLGizmoCut3D::render_slider_input(), Slic3r::GUI::GLGizmoCut3D::render_slider_two_input(), Slic3r::GUI::GLGizmoCut3D::render_snap_specific_input(), Slic3r::GUI::GLGizmoTextureDisplacement::render_texture_library_popup(), Slic3r::GUI::GLGizmoTextureDisplacement::render_tip_media(), Slic3r::GUI::GLGizmoCut3D::render_tooltip_button(), Slic3r::GUI::GLGizmoFdmSupports::render_tooltip_button(), Slic3r::GUI::GLGizmoFuzzySkin::render_tooltip_button(), Slic3r::GUI::GLGizmoMmuSegmentation::render_tooltip_button(), Slic3r::GUI::GLGizmoPainterBase::render_triangles(), Slic3r::GUI::GLGizmoEmboss::rev_checkbox(), Slic3r::GUI::GLGizmoEmboss::rev_input(), Slic3r::GUI::GLGizmoEmboss::rev_slider(), Slic3r::GUI::GLGizmoEmboss::rev_slider(), Slic3r::GUI::GLGizmoEmboss::rev_slider(), Slic3r::GUI::GLGizmoEmboss::revertible(), Slic3r::GUI::GLGizmoMeasure::show_distance_xyz_ui(), Slic3r::GUI::GLGizmoMeasure::show_face_face_assembly_common(), Slic3r::GUI::GLGizmoMeasure::show_face_face_assembly_senior(), and Slic3r::GUI::GLGizmoMeasure::show_selection_ui().

m_is_dark_mode

bool Slic3r::GUI::GLGizmoBase::m_is_dark_mode = false

protectedinherited

Referenced by Slic3r::GUI::GLGizmoMmuSegmentation::draw_color_button(), on_change_color_mode(), Slic3r::GUI::GLGizmoEmboss::on_render_input_window(), Slic3r::GUI::GLGizmoFdmSupports::on_render_input_window(), Slic3r::GUI::GLGizmoFuzzySkin::on_render_input_window(), Slic3r::GUI::GLGizmoMeshBoolean::on_render_input_window(), Slic3r::GUI::GLGizmoMmuSegmentation::on_render_input_window(), Slic3r::GUI::GLGizmoSeam::on_render_input_window(), Slic3r::GUI::GLGizmoSVG::on_render_input_window(), Slic3r::GUI::GLGizmoEmboss::push_button_style(), Slic3r::GUI::GLGizmoMeasure::show_distance_xyz_ui(), and Slic3r::GUI::GLGizmoMeasure::show_selection_ui().

m_job_cancel

std::shared_ptr<std::atomic<bool> > Slic3r::GUI::GLGizmoSVG::m_job_cancel = nullptr

private

Referenced by create_volume(), create_volume(), create_volume(), create_volume(), on_mouse_for_translate(), process(), and set_volume_by_selection().

m_keep_ratio

bool Slic3r::GUI::GLGizmoSVG::m_keep_ratio = true

private

Referenced by draw_size().

m_keep_up

bool Slic3r::GUI::GLGizmoSVG::m_keep_up = true

private

Referenced by draw_face_the_camera(), draw_mirroring(), draw_rotation(), on_mouse_for_translate(), and volume_transformation_changed().

m_parent

GLCanvas3D& Slic3r::GUI::GLGizmoBase::m_parent

protectedinherited

Referenced by GLGizmoBase(), Slic3r::GUI::GLGizmoCut3D::add_connector(), Slic3r::GUI::GLGizmoTextureDisplacement::add_texture_layer(), Slic3r::GUI::GLGizmoCut3D::apply_color_clip_plane_colors(), Slic3r::GUI::GLGizmoTextureDisplacement::apply_projection_frame(), Slic3r::GUI::GLGizmoSimplify::apply_simplify(), Slic3r::GUI::GLGizmoTextureDisplacement::apply_view_mode(), Slic3r::GUI::GLGizmoBrimEars::auto_generate(), Slic3r::GUI::GLGizmoTextureDisplacement::bake(), Slic3r::GUI::GLGizmoCut3D::bounding_box(), Slic3r::GUI::GLGizmoPainterBase::bounding_box(), Slic3r::GUI::GLGizmoEmboss::calculate_scale(), Slic3r::GUI::GLGizmoSVG::calculate_scale(), Slic3r::GUI::GLGizmoTextureDisplacement::capture_view_projection(), Slic3r::GUI::GLGizmoMove3D::change_cs_by_selection(), Slic3r::GUI::GLGizmoScale3D::change_cs_by_selection(), Slic3r::GUI::GLGizmoEmboss::close(), Slic3r::GUI::GLGizmoSimplify::close(), Slic3r::GUI::GLGizmoSVG::close(), Slic3r::GUI::GLGizmoTextureDisplacement::close_image_adjust(), Slic3r::GUI::GLGizmoEmboss::create_volume(), Slic3r::GUI::GLGizmoEmboss::create_volume(), Slic3r::GUI::GLGizmoSVG::create_volume(), Slic3r::GUI::GLGizmoSVG::create_volume(), Slic3r::GUI::GLGizmoSVG::create_volume(), Slic3r::GUI::GLGizmoSVG::create_volume(), Slic3r::GUI::GLGizmoFlatten::data_changed(), Slic3r::GUI::GLGizmoMeasure::data_changed(), Slic3r::GUI::GLGizmoMove3D::data_changed(), Slic3r::GUI::GLGizmoPainterBase::data_changed(), Slic3r::GUI::GLGizmoRotate3D::data_changed(), Slic3r::GUI::GLGizmoScale3D::data_changed(), Slic3r::GUI::GLGizmoCut3D::delete_selected_connectors(), Slic3r::GUI::GLGizmoEmboss::do_mirror(), do_stop_dragging(), Slic3r::GUI::GLGizmoEmboss::draw_advanced(), Slic3r::GUI::GLGizmoSVG::draw_distance(), Slic3r::GUI::GLGizmoSVG::draw_face_the_camera(), Slic3r::GUI::GLGizmoSVG::draw_filename(), Slic3r::GUI::GLGizmoSVG::draw_mirroring(), Slic3r::GUI::GLGizmoEmboss::draw_model_type(), Slic3r::GUI::GLGizmoSVG::draw_model_type(), Slic3r::GUI::GLGizmoSVG::draw_rotation(), Slic3r::GUI::GLGizmoSVG::draw_size(), Slic3r::GUI::GLGizmoEmboss::draw_style_list(), Slic3r::GUI::GLGizmoEmboss::draw_window(), Slic3r::GUI::GLGizmoTextureDisplacement::ease_wheel_scroll(), Slic3r::GUI::GLGizmoBrimEars::find_single(), Slic3r::GUI::GLGizmoBrimEars::first_layer_slicer(), Slic3r::GUI::GLGizmoMeshBoolean::generate_new_volume(), Slic3r::GUI::GLGizmoPainterBase::get_projected_height_range(), Slic3r::GUI::GLGizmoMove3D::get_tooltip(), Slic3r::GUI::GLGizmoScale3D::get_tooltip(), Slic3r::GUI::GLGizmoBrimEars::gizmo_event(), Slic3r::GUI::GLGizmoMeasure::gizmo_event(), Slic3r::GUI::GLGizmoMeshBoolean::gizmo_event(), Slic3r::GUI::GLGizmoPainterBase::gizmo_event(), GizmoImguiSetNextWIndowPos(), Slic3r::GUI::GLGizmoCut3D::has_valid_groove(), Slic3r::GUI::GLGizmoSimplify::init_model(), Slic3r::GUI::GLGizmoMeasure::init_plane_glmodel(), Slic3r::GUI::GLGizmoFdmSupports::init_print_instance(), Slic3r::GUI::GLGizmoPainterBase::mesh_trafo_matrices(), Slic3r::GUI::GLGizmoTextureDisplacement::move_texture_layer(), Slic3r::GUI::GLGizmoMove3D::on_dragging(), Slic3r::GUI::GLGizmoAssembly::on_is_activable(), Slic3r::GUI::GLGizmoBrimEars::on_is_activable(), Slic3r::GUI::GLGizmoCut3D::on_is_activable(), Slic3r::GUI::GLGizmoFlatten::on_is_activable(), Slic3r::GUI::GLGizmoMeasure::on_is_activable(), Slic3r::GUI::GLGizmoMeshBoolean::on_is_activable(), Slic3r::GUI::GLGizmoMmuSegmentation::on_is_activable(), Slic3r::GUI::GLGizmoMove3D::on_is_activable(), Slic3r::GUI::GLGizmoPainterBase::on_is_activable(), Slic3r::GUI::GLGizmoRotate3D::on_is_activable(), Slic3r::GUI::GLGizmoScale3D::on_is_activable(), Slic3r::GUI::GLGizmoSimplify::on_is_activable(), Slic3r::GUI::GLGizmoTextureDisplacement::on_is_activable(), Slic3r::GUI::GLGizmoTextureDisplacement::on_island_edited(), Slic3r::GUI::GLGizmoCut3D::on_load(), Slic3r::GUI::GLGizmoBrimEars::on_mouse(), Slic3r::GUI::GLGizmoCut3D::on_mouse(), Slic3r::GUI::GLGizmoEmboss::on_mouse(), Slic3r::GUI::GLGizmoFlatten::on_mouse(), Slic3r::GUI::GLGizmoMeasure::on_mouse(), Slic3r::GUI::GLGizmoPainterBase::on_mouse(), Slic3r::GUI::GLGizmoRotate3D::on_mouse(), Slic3r::GUI::GLGizmoScale3D::on_mouse(), Slic3r::GUI::GLGizmoSVG::on_mouse(), Slic3r::GUI::GLGizmoTextureDisplacement::on_mouse_adjust_texture(), Slic3r::GUI::GLGizmoEmboss::on_mouse_change_selection(), Slic3r::GUI::GLGizmoEmboss::on_mouse_for_rotation(), Slic3r::GUI::GLGizmoSVG::on_mouse_for_rotation(), Slic3r::GUI::GLGizmoEmboss::on_mouse_for_translate(), Slic3r::GUI::GLGizmoSVG::on_mouse_for_translate(), Slic3r::GUI::GLGizmoTextureDisplacement::on_mouse_seam(), Slic3r::GUI::GLGizmoFdmSupports::on_opening(), Slic3r::GUI::GLGizmoCut3D::on_register_raycasters_for_picking(), Slic3r::GUI::GLGizmoFlatten::on_register_raycasters_for_picking(), Slic3r::GUI::GLGizmoMove3D::on_register_raycasters_for_picking(), Slic3r::GUI::GLGizmoRotate3D::on_register_raycasters_for_picking(), Slic3r::GUI::GLGizmoScale3D::on_register_raycasters_for_picking(), Slic3r::GUI::GLGizmoBrimEars::on_render(), Slic3r::GUI::GLGizmoCut3D::on_render(), Slic3r::GUI::GLGizmoEmboss::on_render(), Slic3r::GUI::GLGizmoFlatten::on_render(), Slic3r::GUI::GLGizmoMeasure::on_render(), Slic3r::GUI::GLGizmoMeshBoolean::on_render(), Slic3r::GUI::GLGizmoMove3D::on_render(), Slic3r::GUI::GLGizmoRotate::on_render(), Slic3r::GUI::GLGizmoSimplify::on_render(), Slic3r::GUI::GLGizmoSVG::on_render(), Slic3r::GUI::GLGizmoAssembly::on_render_input_window(), Slic3r::GUI::GLGizmoBrimEars::on_render_input_window(), Slic3r::GUI::GLGizmoCut3D::on_render_input_window(), Slic3r::GUI::GLGizmoEmboss::on_render_input_window(), Slic3r::GUI::GLGizmoFdmSupports::on_render_input_window(), Slic3r::GUI::GLGizmoFuzzySkin::on_render_input_window(), Slic3r::GUI::GLGizmoMeasure::on_render_input_window(), Slic3r::GUI::GLGizmoMeshBoolean::on_render_input_window(), Slic3r::GUI::GLGizmoMmuSegmentation::on_render_input_window(), Slic3r::GUI::GLGizmoSeam::on_render_input_window(), Slic3r::GUI::GLGizmoSimplify::on_render_input_window(), Slic3r::GUI::GLGizmoSVG::on_render_input_window(), Slic3r::GUI::GLGizmoTextureDisplacement::on_render_input_window(), Slic3r::GUI::GLGizmoCut3D::on_set_state(), Slic3r::GUI::GLGizmoEmboss::on_set_state(), Slic3r::GUI::GLGizmoMeasure::on_set_state(), Slic3r::GUI::GLGizmoMmuSegmentation::on_set_state(), Slic3r::GUI::GLGizmoPainterBase::on_set_state(), Slic3r::GUI::GLGizmoSimplify::on_set_state(), Slic3r::GUI::GLGizmoSVG::on_set_state(), Slic3r::GUI::GLGizmoEmboss::on_shortcut_key(), Slic3r::GUI::GLGizmoFdmSupports::on_shutdown(), Slic3r::GUI::GLGizmoFuzzySkin::on_shutdown(), Slic3r::GUI::GLGizmoMmuSegmentation::on_shutdown(), Slic3r::GUI::GLGizmoSeam::on_shutdown(), Slic3r::GUI::GLGizmoTextureDisplacement::on_shutdown(), Slic3r::GUI::GLGizmoMove3D::on_start_dragging(), Slic3r::GUI::GLGizmoRotate::on_start_dragging(), Slic3r::GUI::GLGizmoEmboss::on_stop_dragging(), Slic3r::GUI::GLGizmoMove3D::on_stop_dragging(), Slic3r::GUI::GLGizmoRotate3D::on_stop_dragging(), Slic3r::GUI::GLGizmoScale3D::on_stop_dragging(), Slic3r::GUI::GLGizmoSVG::on_stop_dragging(), Slic3r::GUI::GLGizmoBrimEars::on_unregister_raycasters_for_picking(), Slic3r::GUI::GLGizmoCut3D::on_unregister_raycasters_for_picking(), Slic3r::GUI::GLGizmoFlatten::on_unregister_raycasters_for_picking(), Slic3r::GUI::GLGizmoMove3D::on_unregister_raycasters_for_picking(), Slic3r::GUI::GLGizmoRotate3D::on_unregister_raycasters_for_picking(), Slic3r::GUI::GLGizmoScale3D::on_unregister_raycasters_for_picking(), Slic3r::GUI::GLGizmoTextureDisplacement::on_uv_command(), Slic3r::GUI::GLGizmoTextureDisplacement::panel_tooltip(), Slic3r::GUI::GLGizmoCut3D::perform_cut(), Slic3r::GUI::GLGizmoEmboss::process(), Slic3r::GUI::GLGizmoSVG::process(), Slic3r::GUI::GLGizmoCut3D::process_contours(), Slic3r::GUI::GLGizmoCut3D::process_cut_line(), Slic3r::GUI::GLGizmoTextureDisplacement::queue_prepare(), Slic3r::GUI::GLGizmoTextureDisplacement::queue_preview_job(), Slic3r::GUI::GLGizmoBrimEars::register_single_mesh_pick(), Slic3r::GUI::GLGizmoMeasure::register_single_mesh_pick(), Slic3r::GUI::GLGizmoEmboss::reinit_text_lines(), Slic3r::GUI::GLGizmoMmuSegmentation::remap_filament_assignments(), Slic3r::GUI::GLGizmoTextureDisplacement::remove_texture_layer(), Slic3r::GUI::GLGizmoTextureDisplacement::render_adjust_texture_gizmo(), Slic3r::GUI::GLGizmoMove3D::render_align_preview(), Slic3r::GUI::GLGizmoAssembly::render_assembly_mode_combo(), render_combo(), Slic3r::GUI::GLGizmoCut3D::render_connectors_input_window(), Slic3r::GUI::GLGizmoPainterBase::render_cursor(), Slic3r::GUI::GLGizmoPainterBase::render_cursor_circle(), Slic3r::GUI::GLGizmoPainterBase::render_cursor_height_range(), Slic3r::GUI::GLGizmoCut3D::render_cut_mode_combo(), Slic3r::GUI::GLGizmoCut3D::render_cut_plane_input_window(), Slic3r::GUI::GLGizmoMeasure::render_dimensioning(), Slic3r::GUI::GLGizmoMeasure::render_follows_cursor(), Slic3r::GUI::GLGizmoPainterBase::render_follows_cursor(), Slic3r::GUI::GLGizmoTextureDisplacement::render_image_adjust_window(), render_input_window(), Slic3r::GUI::GLGizmoTextureDisplacement::render_island_overlay(), Slic3r::GUI::GLGizmoTextureDisplacement::render_paint_overlay(), Slic3r::GUI::GLGizmoTextureDisplacement::render_painted_colors(), Slic3r::GUI::GLGizmoFdmSupports::render_painter_gizmo(), Slic3r::GUI::GLGizmoFuzzySkin::render_painter_gizmo(), Slic3r::GUI::GLGizmoMmuSegmentation::render_painter_gizmo(), Slic3r::GUI::GLGizmoSeam::render_painter_gizmo(), Slic3r::GUI::GLGizmoTextureDisplacement::render_painter_gizmo(), Slic3r::GUI::GLGizmoTextureDisplacement::render_preview_mesh(), Slic3r::GUI::GLGizmoTextureDisplacement::render_seam_overlay(), Slic3r::GUI::GLGizmoTextureDisplacement::render_shaded_preview_mesh(), Slic3r::GUI::GLGizmoTextureDisplacement::render_subdivide_preview(), Slic3r::GUI::GLGizmoTextureDisplacement::render_texture_library_popup(), Slic3r::GUI::GLGizmoTextureDisplacement::render_tip_media(), Slic3r::GUI::GLGizmoCut3D::render_tooltip_button(), Slic3r::GUI::GLGizmoFdmSupports::render_tooltip_button(), Slic3r::GUI::GLGizmoFuzzySkin::render_tooltip_button(), Slic3r::GUI::GLGizmoMmuSegmentation::render_tooltip_button(), Slic3r::GUI::GLGizmoPainterBase::render_triangles(), Slic3r::GUI::GLGizmoTextureDisplacement::render_uvcheck_mesh(), Slic3r::GUI::GLGizmoTextureDisplacement::render_wireframe_overlay(), Slic3r::GUI::GLGizmoSimplify::request_rerender(), Slic3r::GUI::GLGizmoCut3D::reset_cut_plane(), Slic3r::GUI::GLGizmoEmboss::reset_to_default_style(), Slic3r::GUI::GLGizmoTextureDisplacement::run_stage_debug(), Slic3r::GUI::GLGizmoFdmSupports::run_thread(), Slic3r::GUI::GLGizmoTextureDisplacement::run_uv_command(), Slic3r::GUI::GLGizmoTextureDisplacement::seam_edge_at(), Slic3r::GUI::GLGizmoTextureDisplacement::seam_vertex_at(), Slic3r::GUI::GLGizmoFdmSupports::select_facets_by_angle(), Slic3r::GUI::GLGizmoTextureDisplacement::select_visible_faces(), Slic3r::GUI::GLGizmoTextureDisplacement::select_whole_model(), Slic3r::GUI::GLGizmoCut3D::set_connectors_editing(), Slic3r::GUI::GLGizmoMeasure::set_distance(), Slic3r::GUI::GLGizmoTextureDisplacement::set_layer_texture(), Slic3r::GUI::GLGizmoMeasure::set_parallel_distance(), Slic3r::GUI::GLGizmoMeasure::set_to_around_center_of_faces(), Slic3r::GUI::GLGizmoMeasure::set_to_parallel(), Slic3r::GUI::GLGizmoMeasure::set_to_reverse_rotation(), Slic3r::GUI::GLGizmoEmboss::set_volume_by_selection(), Slic3r::GUI::GLGizmoSVG::set_volume_by_selection(), Slic3r::GUI::GLGizmoCut3D::set_volumes_picking_state(), Slic3r::GUI::GLGizmoTextureDisplacement::show_debug_stage(), Slic3r::GUI::GLGizmoTextureDisplacement::show_projector(), Slic3r::GUI::GLGizmoTextureDisplacement::smooth_model(), Slic3r::GUI::GLGizmoTextureDisplacement::subdivide_model(), Slic3r::GUI::GLGizmoCut3D::toggle_model_objects_visibility(), Slic3r::GUI::GLGizmoCut3D::transformed_bounding_box(), Slic3r::GUI::GLGizmoBrimEars::unproject_on_mesh(), Slic3r::GUI::GLGizmoCut3D::update_bb(), Slic3r::GUI::GLGizmoBrimEars::update_cache_radius(), Slic3r::GUI::GLGizmoCut3D::update_clipper(), Slic3r::GUI::GLGizmoPainterBase::update_contours(), Slic3r::GUI::GLGizmoScale3D::update_grabbers_data(), Slic3r::GUI::GLGizmoTextureDisplacement::update_image_adjust_preview(), Slic3r::GUI::GLGizmoBrimEars::update_model_object(), Slic3r::GUI::GLGizmoFdmSupports::update_model_object(), Slic3r::GUI::GLGizmoFuzzySkin::update_model_object(), Slic3r::GUI::GLGizmoMmuSegmentation::update_model_object(), Slic3r::GUI::GLGizmoSeam::update_model_object(), Slic3r::GUI::GLGizmoTextureDisplacement::update_model_object(), Slic3r::GUI::GLGizmoPainterBase::update_raycast_cache(), Slic3r::GUI::GLGizmoBrimEars::update_raycasters(), use_grabbers(), Slic3r::GUI::GLGizmoEmboss::volume_transformation_changed(), Slic3r::GUI::GLGizmoSVG::volume_transformation_changed(), and Slic3r::GUI::GLGizmoEmboss::volume_transformation_changing().

m_raycast_manager

RaycastManager Slic3r::GUI::GLGizmoSVG::m_raycast_manager

private

Referenced by create_volume(), create_volume(), create_volume(), create_volume(), on_mouse_for_translate(), process(), and set_volume_by_selection().

m_rotate_gizmo

GLGizmoRotate Slic3r::GUI::GLGizmoSVG::m_rotate_gizmo

private

Referenced by GLGizmoSVG(), on_disable_grabber(), on_dragging(), on_enable_grabber(), on_init(), on_mouse_for_rotation(), on_register_raycasters_for_picking(), on_render(), on_set_hover_id(), on_set_state(), on_start_dragging(), on_stop_dragging(), and on_unregister_raycasters_for_picking().

m_rotate_start_angle

std::optional<float> Slic3r::GUI::GLGizmoSVG::m_rotate_start_angle

private

Referenced by on_mouse_for_rotation(), and on_stop_dragging().

m_scale_depth

std::optional<float> Slic3r::GUI::GLGizmoSVG::m_scale_depth

private

Referenced by calculate_scale(), and draw_depth().

m_scale_height

std::optional<float> Slic3r::GUI::GLGizmoSVG::m_scale_height

private

Referenced by calculate_scale(), draw_size(), and get_scale_for_tolerance().

m_scale_width

std::optional<float> Slic3r::GUI::GLGizmoSVG::m_scale_width

private

Referenced by calculate_scale(), draw_size(), and get_scale_for_tolerance().

m_shape_bb

BoundingBox Slic3r::GUI::GLGizmoSVG::m_shape_bb

private

Referenced by draw_size(), and set_volume_by_selection().

m_shape_warnings

std::vector<std::string> Slic3r::GUI::GLGizmoSVG::m_shape_warnings

private

Referenced by draw_filename(), draw_preview(), reset_volume(), and set_volume_by_selection().

m_shortcut

std::optional<Shortcut> Slic3r::GUI::GLGizmoBase::m_shortcut

protectedinherited

Referenced by get_name(), Slic3r::GUI::GLGizmoAssembly::on_init(), Slic3r::GUI::GLGizmoBrimEars::on_init(), Slic3r::GUI::GLGizmoCut3D::on_init(), Slic3r::GUI::GLGizmoEmboss::on_init(), Slic3r::GUI::GLGizmoFdmSupports::on_init(), Slic3r::GUI::GLGizmoFlatten::on_init(), Slic3r::GUI::GLGizmoFuzzySkin::on_init(), Slic3r::GUI::GLGizmoMeasure::on_init(), Slic3r::GUI::GLGizmoMeshBoolean::on_init(), Slic3r::GUI::GLGizmoMmuSegmentation::on_init(), Slic3r::GUI::GLGizmoMove3D::on_init(), Slic3r::GUI::GLGizmoRotate3D::on_init(), Slic3r::GUI::GLGizmoScale3D::on_init(), Slic3r::GUI::GLGizmoSeam::on_init(), Slic3r::GUI::GLGizmoTextureDisplacement::on_init(), and shortcut().

m_sprite_id

unsigned int Slic3r::GUI::GLGizmoBase::m_sprite_id

protectedinherited

Referenced by GLGizmoBase(), and get_sprite_id().

m_state

EState Slic3r::GUI::GLGizmoBase::m_state

protectedinherited

Referenced by GLGizmoBase(), Slic3r::GUI::GLGizmoTextureDisplacement::bake(), Slic3r::GUI::GLGizmoTextureDisplacement::close_image_adjust(), Slic3r::GUI::GLGizmoMmuSegmentation::data_changed(), Slic3r::GUI::GLGizmoPainterBase::data_changed(), get_state(), Slic3r::GUI::GLGizmoFlatten::is_plane_update_necessary(), load(), Slic3r::GUI::GLGizmoAssembly::on_get_name(), Slic3r::GUI::GLGizmoBrimEars::on_get_name(), Slic3r::GUI::GLGizmoMeasure::on_get_name(), Slic3r::GUI::GLGizmoMove3D::on_get_name(), Slic3r::GUI::GLGizmoRotate3D::on_get_name(), Slic3r::GUI::GLGizmoScale3D::on_get_name(), Slic3r::GUI::GLGizmoBrimEars::on_render(), Slic3r::GUI::GLGizmoCut3D::on_render(), Slic3r::GUI::GLGizmoBrimEars::on_set_state(), Slic3r::GUI::GLGizmoCut3D::on_set_state(), Slic3r::GUI::GLGizmoEmboss::on_set_state(), Slic3r::GUI::GLGizmoMeasure::on_set_state(), Slic3r::GUI::GLGizmoMeshBoolean::on_set_state(), Slic3r::GUI::GLGizmoPainterBase::on_set_state(), Slic3r::GUI::GLGizmoRotate3D::on_set_state(), Slic3r::GUI::GLGizmoSimplify::on_set_state(), Slic3r::GUI::GLGizmoSVG::on_set_state(), Slic3r::GUI::GLGizmoTextureDisplacement::queue_prepare(), Slic3r::GUI::GLGizmoTextureDisplacement::queue_preview_job(), Slic3r::GUI::GLGizmoBrimEars::set_brim_data(), set_state(), and Slic3r::GUI::GLGizmoSimplify::worker_finished().

m_surface_drag

std::optional<SurfaceDrag> Slic3r::GUI::GLGizmoSVG::m_surface_drag

private

Referenced by on_mouse_for_translate(), on_render(), and on_render_input_window().

m_texture

Texture Slic3r::GUI::GLGizmoSVG::m_texture

private

Referenced by draw_filename(), draw_preview(), and reset_volume().

m_volume

ModelVolume* Slic3r::GUI::GLGizmoSVG::m_volume = nullptr

private

Referenced by data_changed(), draw_distance(), draw_filename(), draw_model_type(), draw_preview(), draw_rotation(), draw_use_surface(), draw_window(), on_mouse(), on_mouse_for_translate(), on_render(), on_stop_dragging(), process(), reset_volume(), set_volume_by_selection(), and volume_transformation_changed().

m_volume_id

ObjectID Slic3r::GUI::GLGizmoSVG::m_volume_id

private

Referenced by draw_window(), on_mouse(), on_render(), process(), reset_volume(), and set_volume_by_selection().

m_volume_shape

EmbossShape Slic3r::GUI::GLGizmoSVG::m_volume_shape

private

Referenced by draw_depth(), draw_filename(), draw_mirroring(), draw_size(), draw_use_surface(), process(), reset_volume(), and set_volume_by_selection().

---

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

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