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

Inheritance diagram for Slic3r::GUI::GLGizmosManager:

Collaboration diagram for Slic3r::GUI::GLGizmosManager:

Classes
struct	Layout

Public Types
enum	EType : unsigned char { Move , Rotate , Scale , Flatten , Cut , MeshBoolean , FdmSupports , Seam , FuzzySkin , MmSegmentation , TextureDisplacement , Emboss , Svg , Measure , Assembly , Simplify , BrimEars , Undefined }
enum	MENU_ICON_NAME { IC_TOOLBAR_RESET = 0 , IC_TOOLBAR_RESET_HOVER , IC_TOOLBAR_RESET_ZERO , IC_TOOLBAR_RESET_ZERO_HOVER , IC_TOOLBAR_TOOLTIP , IC_TOOLBAR_WIKI_GUIDE , IC_TOOLBAR_VIDEO_GUIDE , IC_NAME_COUNT , IC_CANVAS_MENU , IC_CANVAS_MENU_HOVER , IC_CANVAS_MENU_DARK , IC_CANVAS_MENU_DARK_HOVER , IC_CANVAS_ZOOM , IC_CANVAS_ZOOM_HOVER , IC_CANVAS_ZOOM_DARK , IC_CANVAS_ZOOM_DARK_HOVER , IC_CANVAS_SECTION , IC_CANVAS_SECTION_HOVER , IC_CANVAS_SECTION_DARK , IC_CANVAS_SECTION_DARK_HOVER , IC_CANVAS_SECTION_ACTIVE , IC_CANVAS_SECTION_ACTIVE_HOVER , IC_CANVAS_SECTION_ACTIVE_DARK , IC_CANVAS_SECTION_ACTIVE_DARK_HOVER , IC_ALIGN_X_MIN , IC_ALIGN_X_CENTER , IC_ALIGN_X_MAX , IC_ALIGN_Y_MIN , IC_ALIGN_Y_CENTER , IC_ALIGN_Y_MAX , IC_ALIGN_Z_MIN , IC_ALIGN_Z_CENTER , IC_ALIGN_Z_MAX , IC_DISTRIBUTE_X , IC_DISTRIBUTE_Y , IC_DISTRIBUTE_Z , IC_ALIGN_X_MIN_DARK , IC_ALIGN_X_CENTER_DARK , IC_ALIGN_X_MAX_DARK , IC_ALIGN_Y_MIN_DARK , IC_ALIGN_Y_CENTER_DARK , IC_ALIGN_Y_MAX_DARK , IC_ALIGN_Z_MIN_DARK , IC_ALIGN_Z_CENTER_DARK , IC_ALIGN_Z_MAX_DARK , IC_DISTRIBUTE_X_DARK , IC_DISTRIBUTE_Y_DARK , IC_DISTRIBUTE_Z_DARK }
using	Timestamp = uint64_t

Public Member Functions
	GLGizmosManager (GLCanvas3D &parent)
void	switch_gizmos_icon_filename ()
bool	init ()
bool	init_icon_textures ()
float	get_layout_scale ()
bool	init_arrow (const std::string &filename)
template<class Archive>
void	load (Archive &ar)
template<class Archive>
void	save (Archive &ar) const
bool	is_enabled () const
void	set_enabled (bool enable)
void	set_icon_dirty ()
void	set_overlay_icon_size (float size)
void	set_overlay_scale (float scale)
void	refresh_on_off_state ()
void	reset_all_states ()
bool	open_gizmo (EType type)
bool	check_gizmos_closed_except (EType) const
void	set_hover_id (int id)
void	update_data ()
	Distribute information about different data into active gizmo Should be called when selection changed.
void	update_section_view ()
EType	get_current_type () const
GLGizmoBase *	get_current () const
GLGizmoBase *	get_gizmo (GLGizmosManager::EType type) const
EType	get_gizmo_from_name (const std::string &gizmo_name) const
bool	is_running () const
bool	open_gizmo_by_shortcut (Shortcut shortcut)
bool	on_delete_key ()
bool	is_dragging () const
void *	get_icon_texture_id (MENU_ICON_NAME icon)
void *	get_icon_texture_id (MENU_ICON_NAME icon) const
bool	is_paint_gizmo ()
bool	is_allow_select_all ()
bool	is_allow_multi_select_parts_or_objects () const
std::optional< ClippingPlane >	get_clipping_plane () const
bool	wants_reslice_supports_on_undo () const
bool	is_in_editing_mode (bool error_notification=false) const
bool	is_hiding_instances () const
void	on_change_color_mode (bool is_dark)
void	render_current_gizmo () const
void	render_painter_gizmo ()
void	render_overlay ()
void	render_overlay_input_window ()
size_t	get_overlay_state_hash () const
void	render_arrow (const GLCanvas3D &parent, EType highlighted_type) const
std::string	get_tooltip () const
bool	on_mouse (const wxMouseEvent &mouse_event)
bool	on_mouse_wheel (const wxMouseEvent &evt)
bool	on_char (wxKeyEvent &evt)
bool	on_key (wxKeyEvent &evt)
void	update_after_undo_redo (const UndoRedo::Snapshot &snapshot)
int	get_selectable_icons_cnt () const
void	set_highlight (EType gizmo, bool highlight_shown)
bool	get_highlight_state () const
float	get_scaled_total_height () const
float	get_scaled_total_width () const
GizmoObjectManipulation &	get_object_manipulation ()
bool	get_uniform_scaling () const
ObjectID	id () const
virtual Timestamp	timestamp () const

Static Public Attributes
static const float	Default_Icons_Size = 64

Protected Member Functions
void	set_new_unique_id ()
void	set_invalid_id ()
void	copy_id (const ObjectBase &rhs)
virtual void	assign_new_unique_ids_recursive ()

Private Member Functions
std::vector< size_t >	get_selectable_idxs () const
EType	get_gizmo_from_mouse (const Vec2d &mouse_pos) const
bool	activate_gizmo (EType type)
void	on_set_color_timer (wxTimerEvent &evt)
bool	gizmos_toolbar_on_mouse (const wxMouseEvent &mouse_event)
	Process mouse event on gizmo toolbar.
bool	gizmo_event (SLAGizmoEventType action, const Vec2d &mouse_position=Vec2d::Zero(), bool shift_down=false, bool alt_down=false, bool control_down=false)
void	render_background (float left, float top, float right, float bottom, float border_w, float border_h) const
void	do_render_overlay (bool draw_icons) const
bool	generate_icons_texture ()
void	update_hover_state (const EType &type)
bool	grabber_contains_mouse () const
template<class Archive>
void	serialize (Archive &ar)

Static Private Member Functions
static ObjectID	generate_new_id ()
template<class Archive>
static void	load_and_construct (Archive &ar, cereal::construct< ObjectBase > &construct)

Private Attributes
GLCanvas3D &	m_parent
bool	m_enabled
std::vector< std::unique_ptr< GLGizmoBase > >	m_gizmos
GLTexture	m_icons_texture
bool	m_icons_texture_dirty
BackgroundTexture	m_background_texture
GLTexture	m_arrow_texture
Layout	m_layout
EType	m_current
EType	m_hover
std::pair< EType, bool >	m_highlight
GizmoObjectManipulation	m_object_manipulation
std::string	m_tooltip
bool	m_serializing
std::unique_ptr< CommonGizmosDataPool >	m_common_gizmos_data
wxTimer	m_timer_set_color
int	m_pending_color_shortcut_tens = 0
bool	m_is_dark = false
bool	m_restore_realistic_view_after_paint = false
ObjectID	m_id

Static Private Attributes
static std::map< int, void * >	icon_list = {}
static size_t	s_last_id = 0

Detailed Description

Member Typedef Documentation

◆ Timestamp

using Slic3r::ObjectBase::Timestamp = uint64_t

inherited

Member Enumeration Documentation

◆ EType

enum Slic3r::GUI::GLGizmosManager::EType : unsigned char

Enumerator
Move
Rotate
Scale
Flatten
Cut
MeshBoolean
FdmSupports
Seam
FuzzySkin
MmSegmentation
TextureDisplacement
Emboss
Svg
Measure
Assembly
Simplify
BrimEars
Undefined

    {
        // Order must match index in m_gizmos!
        Move,
        Rotate,
        Scale,
        Flatten,
        Cut,
        MeshBoolean,
        FdmSupports,
        Seam,
        FuzzySkin,
        MmSegmentation,
        TextureDisplacement,
        Emboss,
        Svg,
        Measure,
        Assembly,
        Simplify,
        BrimEars,
        //SlaSupports,
        // BBS
        //FaceRecognition,
        //Hollow,
        Undefined,
    };

◆ MENU_ICON_NAME

enum Slic3r::GUI::GLGizmosManager::MENU_ICON_NAME

Enumerator
IC_TOOLBAR_RESET
IC_TOOLBAR_RESET_HOVER
IC_TOOLBAR_RESET_ZERO
IC_TOOLBAR_RESET_ZERO_HOVER
IC_TOOLBAR_TOOLTIP
IC_TOOLBAR_WIKI_GUIDE
IC_TOOLBAR_VIDEO_GUIDE
IC_NAME_COUNT
IC_CANVAS_MENU
IC_CANVAS_MENU_HOVER
IC_CANVAS_MENU_DARK
IC_CANVAS_MENU_DARK_HOVER
IC_CANVAS_ZOOM
IC_CANVAS_ZOOM_HOVER
IC_CANVAS_ZOOM_DARK
IC_CANVAS_ZOOM_DARK_HOVER
IC_CANVAS_SECTION
IC_CANVAS_SECTION_HOVER
IC_CANVAS_SECTION_DARK
IC_CANVAS_SECTION_DARK_HOVER
IC_CANVAS_SECTION_ACTIVE
IC_CANVAS_SECTION_ACTIVE_HOVER
IC_CANVAS_SECTION_ACTIVE_DARK
IC_CANVAS_SECTION_ACTIVE_DARK_HOVER
IC_ALIGN_X_MIN
IC_ALIGN_X_CENTER
IC_ALIGN_X_MAX
IC_ALIGN_Y_MIN
IC_ALIGN_Y_CENTER
IC_ALIGN_Y_MAX
IC_ALIGN_Z_MIN
IC_ALIGN_Z_CENTER
IC_ALIGN_Z_MAX
IC_DISTRIBUTE_X
IC_DISTRIBUTE_Y
IC_DISTRIBUTE_Z
IC_ALIGN_X_MIN_DARK
IC_ALIGN_X_CENTER_DARK
IC_ALIGN_X_MAX_DARK
IC_ALIGN_Y_MIN_DARK
IC_ALIGN_Y_CENTER_DARK
IC_ALIGN_Y_MAX_DARK
IC_ALIGN_Z_MIN_DARK
IC_ALIGN_Z_CENTER_DARK
IC_ALIGN_Z_MAX_DARK
IC_DISTRIBUTE_X_DARK
IC_DISTRIBUTE_Y_DARK
IC_DISTRIBUTE_Z_DARK

                        {
        IC_TOOLBAR_RESET            = 0,
        IC_TOOLBAR_RESET_HOVER,
        IC_TOOLBAR_RESET_ZERO,
        IC_TOOLBAR_RESET_ZERO_HOVER,
        IC_TOOLBAR_TOOLTIP,
        IC_TOOLBAR_WIKI_GUIDE,
        IC_TOOLBAR_VIDEO_GUIDE,
        IC_NAME_COUNT,
        IC_CANVAS_MENU,
        IC_CANVAS_MENU_HOVER,
        IC_CANVAS_MENU_DARK,
        IC_CANVAS_MENU_DARK_HOVER,
        IC_CANVAS_ZOOM,
        IC_CANVAS_ZOOM_HOVER,
        IC_CANVAS_ZOOM_DARK,
        IC_CANVAS_ZOOM_DARK_HOVER,
        IC_CANVAS_SECTION,
        IC_CANVAS_SECTION_HOVER,
        IC_CANVAS_SECTION_DARK,
        IC_CANVAS_SECTION_DARK_HOVER,
        IC_CANVAS_SECTION_ACTIVE,
        IC_CANVAS_SECTION_ACTIVE_HOVER,
        IC_CANVAS_SECTION_ACTIVE_DARK,
        IC_CANVAS_SECTION_ACTIVE_DARK_HOVER,
        IC_ALIGN_X_MIN,
        IC_ALIGN_X_CENTER,
        IC_ALIGN_X_MAX,
        IC_ALIGN_Y_MIN,
        IC_ALIGN_Y_CENTER,
        IC_ALIGN_Y_MAX,
        IC_ALIGN_Z_MIN,
        IC_ALIGN_Z_CENTER,
        IC_ALIGN_Z_MAX,
        IC_DISTRIBUTE_X,
        IC_DISTRIBUTE_Y,
        IC_DISTRIBUTE_Z,
        IC_ALIGN_X_MIN_DARK,
        IC_ALIGN_X_CENTER_DARK,
        IC_ALIGN_X_MAX_DARK,
        IC_ALIGN_Y_MIN_DARK,
        IC_ALIGN_Y_CENTER_DARK,
        IC_ALIGN_Y_MAX_DARK,
        IC_ALIGN_Z_MIN_DARK,
        IC_ALIGN_Z_CENTER_DARK,
        IC_ALIGN_Z_MAX_DARK,
        IC_DISTRIBUTE_X_DARK,
        IC_DISTRIBUTE_Y_DARK,
        IC_DISTRIBUTE_Z_DARK,
    };

Constructor & Destructor Documentation

◆ GLGizmosManager()

Slic3r::GUI::GLGizmosManager::GLGizmosManager ( GLCanvas3D & parent )

explicit

    : m_parent(parent)
    , m_enabled(false)
    , m_icons_texture_dirty(true)
    , m_current(Undefined)
    , m_hover(Undefined)
    , m_tooltip("")
    , m_serializing(false)
    //BBS: GUI refactor: add object manipulation in gizmo
    , m_object_manipulation(parent)
{
    m_timer_set_color.Bind(wxEVT_TIMER, &GLGizmosManager::on_set_color_timer, this);
}

References m_current, m_enabled, m_hover, m_icons_texture_dirty, m_object_manipulation, m_parent, m_serializing, m_timer_set_color, m_tooltip, on_set_color_timer(), and Undefined.

Here is the call graph for this function:

Member Function Documentation

◆ activate_gizmo()

bool Slic3r::GUI::GLGizmosManager::activate_gizmo ( EType type )

private

{
    // already activated
    if (m_current == type)
        return true;
 
    if (m_gizmos.empty())
        return false;
 
    if (m_current != Undefined) {
        // clean up previous gizmo
        GLGizmoBase &old_gizmo = *m_gizmos[m_current];
        old_gizmo.set_state(GLGizmoBase::Off);
        if (old_gizmo.get_state() != GLGizmoBase::Off)
            return false; // gizmo refused to be turned off, do nothing.
 
        old_gizmo.unregister_raycasters_for_picking();
 
        if (!m_serializing && old_gizmo.wants_enter_leave_snapshots())
            Plater::TakeSnapshot
                snapshot(wxGetApp().plater(),
                         old_gizmo.get_gizmo_leaving_text(),
                         UndoRedo::SnapshotType::LeavingGizmoWithAction);
    }
 
    if (type == Undefined) {
        // it is deactivation of gizmo
        if (m_restore_realistic_view_after_paint && wxGetApp().app_config != nullptr) {
            wxGetApp().app_config->set_bool(SETTING_OPENGL_REALISTIC_MODE, true);
            wxGetApp().app_config->save();
            m_restore_realistic_view_after_paint = false;
        }
        m_current = Undefined;
        return true;
    }
 
    // set up new gizmo
    GLGizmoBase& new_gizmo = *m_gizmos[type];
    if (!new_gizmo.is_activable()) return false;
 
    if (type == Seam || type == FdmSupports || type == FuzzySkin) {
        if (wxGetApp().app_config != nullptr && wxGetApp().app_config->get_bool(SETTING_OPENGL_REALISTIC_MODE)) {
            m_restore_realistic_view_after_paint = true;
            wxGetApp().app_config->set_bool(SETTING_OPENGL_REALISTIC_MODE, false);
            wxGetApp().app_config->save();
        }
    } else {
        m_restore_realistic_view_after_paint = false;
    }
 
    if (!m_serializing && new_gizmo.wants_enter_leave_snapshots())
        Plater::TakeSnapshot snapshot(wxGetApp().plater(),
                                      new_gizmo.get_gizmo_entering_text(),
                                      UndoRedo::SnapshotType::EnteringGizmo);
 
    m_current = type;
    new_gizmo.set_state(GLGizmoBase::On);
    if (new_gizmo.get_state() != GLGizmoBase::On) {
        m_current = Undefined;
        return false; // gizmo refused to be turned on.
    }
 
    new_gizmo.register_raycasters_for_picking();
 
    // sucessful activation of gizmo
    return true;
}

Referenced by load(), open_gizmo(), refresh_on_off_state(), and reset_all_states().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ assign_new_unique_ids_recursive()

virtual void Slic3r::ObjectBase::assign_new_unique_ids_recursive ( )

inlineprotectedvirtualinherited

Reimplemented in Slic3r::Model, Slic3r::ModelObject, and Slic3r::ModelVolume.

95{ this->set_new_unique_id(); }

Slic3r::ObjectBase::set_new_unique_id

void set_new_unique_id()

Definition ObjectID.hpp:89

References set_new_unique_id().

Here is the call graph for this function:

◆ check_gizmos_closed_except()

bool Slic3r::GUI::GLGizmosManager::check_gizmos_closed_except ( EType type ) const

{
    if (get_current_type() != type && get_current_type() != Undefined) {
        wxGetApp().plater()->get_notification_manager()->push_notification(
                    NotificationType::CustomSupportsAndSeamRemovedAfterRepair,
                    NotificationManager::NotificationLevel::PrintInfoNotificationLevel,
                    _u8L("Error: Please close all toolbar menus first"));
        return false;
    }
    return true;
}

References _u8L, Slic3r::GUI::CustomSupportsAndSeamRemovedAfterRepair, get_current_type(), Slic3r::GUI::NotificationManager::PrintInfoNotificationLevel, and Undefined.

Referenced by Slic3r::GUI::ObjectList::simplify().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ copy_id()

void Slic3r::ObjectBase::copy_id ( const ObjectBase & rhs )

inlineprotectedinherited

92{ m_id = rhs.id(); }

Slic3r::ObjectBase::m_id

ObjectID m_id

Definition ObjectID.hpp:98

References ObjectBase(), id(), and m_id.

Referenced by Slic3r::CutObjectBase::copy().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ do_render_overlay()

void Slic3r::GUI::GLGizmosManager::do_render_overlay ( bool draw_icons ) const

private

{
    const std::vector<size_t> selectable_idxs = get_selectable_idxs();
    if (selectable_idxs.empty())
        return;
 
    const Size cnv_size = m_parent.get_canvas_size();
    const float cnv_w = (float)cnv_size.get_width();
    const float cnv_h = (float)cnv_size.get_height();
 
    if (cnv_w == 0 || cnv_h == 0)
        return;
 
    const float inv_cnv_w = 1.0f / cnv_w;
    const float inv_cnv_h = 1.0f / cnv_h;
 
    const float height = 2.0f * get_scaled_total_height() * inv_cnv_h;
    const float width  = 2.0f * get_scaled_total_width() * inv_cnv_w;
    const float border_h = 2.0f * m_layout.scaled_border() * inv_cnv_h;
    const float border_w = 2.0f * m_layout.scaled_border() * inv_cnv_w;
 
    float top_x;
    if (m_parent.get_canvas_type() == GLCanvas3D::CanvasAssembleView) {
        top_x = m_parent.get_assembly_paint_toolbar_width() * inv_cnv_w;
    }
    else {
        //BBS: GUI refactor: GLToolbar&&Gizmo adjust
        float main_toolbar_width = (float)m_parent.get_main_toolbar_width();
        float separator_width = (float)m_parent.get_separator_toolbar_width();
        //float space_width = GLGizmosManager::Default_Icons_Size * wxGetApp().toolbar_icon_scale();
        //float zoomed_top_x = 0.5f *(cnv_w + main_toolbar_width - 2 * space_width - width) * inv_zoom;
 
        int main_toolbar_left = -cnv_w + m_parent.get_main_toolbar_offset() * 2;
        //float zoomed_top_x = 0.5f *(main_toolbar_width + collapse_width - width - assemble_view_width) * inv_zoom;
        top_x = main_toolbar_left + main_toolbar_width * 2 + separator_width;
        top_x = top_x * inv_cnv_w;
    }
    float top_y = 1.0f;
 
    if (draw_icons)
        render_background(top_x, top_y, top_x + width, top_y - height, border_w, border_h);
 
    top_x += border_w;
    top_y -= border_h;
 
    const float icons_size_x = 2.0f * m_layout.scaled_icons_size() * inv_cnv_w;
    const float icons_size_y = 2.0f * m_layout.scaled_icons_size() * inv_cnv_h;
    //BBS: GUI refactor: GLToolbar&&Gizmo adjust
    const float stride_x = 2.0f * m_layout.scaled_stride_x() * inv_cnv_w;
 
    const unsigned int icons_texture_id = m_icons_texture.get_id();
    const int tex_width = m_icons_texture.get_width();
    const int tex_height = m_icons_texture.get_height();
 
    if (icons_texture_id == 0 || tex_width <= 1 || tex_height <= 1)
        return;
 
    const float du = (float)(tex_width - 1) / (6.0f * (float)tex_width); // 6 is the number of possible states if the icons
    const float dv = (float)(tex_height - 1) / (float)(m_gizmos.size() * tex_height);
 
    // tiles in the texture are spaced by 1 pixel
    const float u_offset = 1.0f / (float)tex_width;
    const float v_offset = 1.0f / (float)tex_height;
 
    bool is_render_current = false;
 
    for (size_t idx : selectable_idxs) {
        GLGizmoBase* gizmo = m_gizmos[idx].get();
        const unsigned int sprite_id = gizmo->get_sprite_id();
        // higlighted state needs to be decided first so its highlighting in every other state
        const int icon_idx = (m_highlight.first == idx ? (m_highlight.second ? 4 : 5) : (m_current == idx) ? 2 : ((m_hover == idx) ? 1 : (gizmo->is_activable()? 0 : 3)));
 
        const float u_left   = u_offset + icon_idx * du;
        const float u_right  = u_left + du - u_offset;
        const float v_top    = v_offset + sprite_id * dv;
        const float v_bottom = v_top + dv - v_offset;
 
        if (draw_icons)
            GLTexture::render_sub_texture(icons_texture_id, top_x, top_x + icons_size_x, top_y - icons_size_y, top_y, { { u_left, v_bottom }, { u_right, v_bottom }, { u_right, v_top }, { u_left, v_top } });
        if (idx == m_current
            // Orca: Show Svg dialog at the same place as emboss gizmo
            || (m_current == Svg && idx == Emboss)) {
            //BBS: GUI refactor: GLToolbar&&Gizmo adjust
            //render_input_window uses a different coordination(imgui)
            //1. no need to scale by camera zoom, set {0,0} at left-up corner for imgui
            //gizmo->render_input_window(width, 0.5f * cnv_h - zoomed_top_y * zoom, toolbar_top);
            if (!draw_icons)
                m_gizmos[m_current]->render_input_window(0.5 * cnv_w + 0.5f * top_x * cnv_w, get_scaled_total_height(), cnv_h);
 
            is_render_current = true;
        }
        top_x += stride_x;
    }
 
    // BBS simplify gizmo is not a selected gizmo and need to render input window
    if (!draw_icons && !is_render_current && m_current != Undefined) {
        m_gizmos[m_current]->render_input_window(0.5 * cnv_w + 0.5f * top_x * cnv_w, get_scaled_total_height(), cnv_h);
    }
}

References Slic3r::GUI::GLCanvas3D::CanvasAssembleView, Emboss, Slic3r::GUI::Size::get_height(), get_scaled_total_height(), get_scaled_total_width(), get_selectable_idxs(), Slic3r::GUI::GLGizmoBase::get_sprite_id(), Slic3r::GUI::Size::get_width(), Slic3r::GUI::GLGizmoBase::is_activable(), m_current, m_gizmos, m_highlight, m_hover, m_icons_texture, m_layout, m_parent, render_background(), Slic3r::GUI::GLTexture::render_sub_texture(), Svg, and Undefined.

Referenced by render_overlay(), and render_overlay_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ generate_icons_texture()

bool Slic3r::GUI::GLGizmosManager::generate_icons_texture ( )

private

{
    std::string path = resources_dir() + "/images/";
    std::vector<std::string> filenames;
    for (size_t idx=0; idx<m_gizmos.size(); ++idx)
    {
        auto &gizmo = m_gizmos[idx];
        if (gizmo != nullptr)
        {
            const std::string& icon_filename = gizmo->get_icon_filename();
            if (!icon_filename.empty())
                filenames.push_back(path + icon_filename);
        }
    }
 
    std::vector<std::pair<int, bool>> states;
    states.push_back(std::make_pair(1, false)); // Activable
    states.push_back(std::make_pair(0, false)); // Hovered
    states.push_back(std::make_pair(0, true));  // Selected
    states.push_back(std::make_pair(2, false)); // Disabled
    states.push_back(std::make_pair(0, false)); // HighlightedShown
    states.push_back(std::make_pair(2, false)); // HighlightedHidden
 
    unsigned int sprite_size_px = (unsigned int)m_layout.scaled_icons_size();
//    // force even size
//    if (sprite_size_px % 2 != 0)
//        sprite_size_px += 1;
 
    bool res = m_icons_texture.load_from_svg_files_as_sprites_array(filenames, states, sprite_size_px, false);
    if (res)
        m_icons_texture_dirty = false;
 
    return res;
}

References m_gizmos, m_icons_texture, m_icons_texture_dirty, m_layout, and Slic3r::resources_dir().

Referenced by render_overlay().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ generate_new_id()

ObjectID Slic3r::ObjectBase::generate_new_id ( )

inlinestaticprivateinherited

100{ return ObjectID(++ s_last_id); }

Slic3r::ObjectBase::s_last_id

static size_t s_last_id

Definition ObjectID.hpp:101

References s_last_id.

Referenced by ObjectBase(), and set_new_unique_id().

Here is the caller graph for this function:

◆ get_clipping_plane()

std::optional< ClippingPlane > Slic3r::GUI::GLGizmosManager::get_clipping_plane ( ) const

{
    if (! m_common_gizmos_data || ! m_common_gizmos_data->object_clipper())
        return std::nullopt;
    else if (m_common_gizmos_data->object_clipper()->get_position() == 0.)
        return ClippingPlane::ClipsNothing();
    else {
        const ClippingPlane& clp = *m_common_gizmos_data->object_clipper()->get_clipping_plane();
        return ClippingPlane(-clp.get_normal(), clp.get_data()[3]);
    }
}

References Slic3r::GUI::ClippingPlane::ClipsNothing(), Slic3r::GUI::ClippingPlane::get_data(), Slic3r::GUI::ClippingPlane::get_normal(), and m_common_gizmos_data.

Here is the call graph for this function:

◆ get_current()

GLGizmoBase * Slic3r::GUI::GLGizmosManager::get_current ( ) const

{
    return ((m_current == Undefined) || m_gizmos.empty()) ? nullptr : m_gizmos[m_current].get();
}

References m_current, m_gizmos, and Undefined.

Referenced by Slic3r::GUI::GLCanvas3D::_render_objects(), get_tooltip(), grabber_contains_mouse(), is_in_editing_mode(), on_key(), on_set_color_timer(), render_painter_gizmo(), Slic3r::GUI::Plater::priv::take_snapshot(), and update_data().

Here is the caller graph for this function:

◆ get_current_type()

EType Slic3r::GUI::GLGizmosManager::get_current_type ( ) const

inline

299{ return m_current; }

References m_current.

Referenced by Slic3r::GUI::MenuFactory::append_menu_item_edit_svg(), Slic3r::GUI::MenuFactory::append_menu_item_edit_text(), Slic3r::GUI::call_after_if_active(), check_gizmos_closed_except(), anonymous_namespace{EmbossJob.cpp}::create_volume(), anonymous_namespace{EmbossJob.cpp}::CreateObjectJob::finalize(), Slic3r::GUI::ObjectList::list_manipulation(), Slic3r::GUI::ObjectList::OnEditingStarted(), Slic3r::GUI::ObjectList::part_selection_changed(), Slic3r::GUI::GLCanvas3D::CenterOfMass::render(), reset_all_states(), Slic3r::GUI::ObjectList::simplify(), and Slic3r::GUI::GLCanvas3D::toggle_model_objects_visibility().

Here is the caller graph for this function:

◆ get_gizmo()

GLGizmoBase * Slic3r::GUI::GLGizmosManager::get_gizmo ( GLGizmosManager::EType type ) const

{
    return ((type == Undefined) || m_gizmos.empty()) ? nullptr : m_gizmos[type].get();
}

References m_gizmos, and Undefined.

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

Here is the caller graph for this function:

◆ get_gizmo_from_mouse()

GLGizmosManager::EType Slic3r::GUI::GLGizmosManager::get_gizmo_from_mouse ( const Vec2d & mouse_pos ) const

private

{
    if (! m_enabled)
        return Undefined;
 
    float icons_size = m_layout.scaled_icons_size();
    float border     = m_layout.scaled_border();
 
    //BBS: GUI refactor: GLToolbar&&Gizmo adjust
    //float space_width = GLGizmosManager::Default_Icons_Size * wxGetApp().toolbar_icon_scale();;
    float top_x;
    if (m_parent.get_canvas_type() == GLCanvas3D::CanvasAssembleView) {
        const float cnv_w = (float)m_parent.get_canvas_size().get_width();
 
        top_x = 0.5f * cnv_w + 0.5f * (m_parent.get_assembly_paint_toolbar_width());
    } else {
        const float separator_width = m_parent.get_separator_toolbar_width();
 
        top_x = m_parent.get_main_toolbar_offset();
        top_x += m_parent.get_main_toolbar_width() + separator_width / 2 + border;
    }
    float top_y = 0;
    float stride_x = m_layout.scaled_stride_x();
 
    // is mouse vertically in the area?
    //if ((border <= (float)mouse_pos(0) && ((float)mouse_pos(0) <= border + icons_size))) {
    if (((top_y + border) <= (float)mouse_pos(1)) && ((float)mouse_pos(1) <= (top_y + border + icons_size))) {
        // which icon is it on?
        int from_left = (float) mouse_pos(0) - top_x < 0 ? -1 : (int) ((float) mouse_pos(0) - top_x) / stride_x;
        if (from_left < 0)
            return Undefined;
        // is it really on the icon or already past the border?
        if ((float)mouse_pos(0) <= top_x + from_left * stride_x + icons_size) {
            std::vector<size_t> selectable = get_selectable_idxs();
            if (from_left < selectable.size())
                return static_cast<EType>(selectable[from_left]);
        }
    }
    return Undefined;
}

References Slic3r::GUI::GLCanvas3D::CanvasAssembleView, get_selectable_idxs(), m_enabled, m_layout, m_parent, Slic3r::GUI::selectable(), and Undefined.

Referenced by gizmos_toolbar_on_mouse().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_gizmo_from_name()

GLGizmosManager::EType Slic3r::GUI::GLGizmosManager::get_gizmo_from_name ( const std::string & gizmo_name ) const

{
    std::vector<size_t> selectable_idxs = get_selectable_idxs();
    for (size_t idx = 0; idx < selectable_idxs.size(); ++idx)
    {
        std::string filename = m_gizmos[selectable_idxs[idx]]->get_icon_filename();
        filename = filename.substr(0, filename.find_first_of('.'));
        if (filename == gizmo_name)
            return (GLGizmosManager::EType)selectable_idxs[idx];
    }
    return GLGizmosManager::EType::Undefined;
}

References get_selectable_idxs(), m_gizmos, and Undefined.

Here is the call graph for this function:

◆ get_highlight_state()

bool Slic3r::GUI::GLGizmosManager::get_highlight_state ( ) const

inline

360{ return m_highlight.second; }

References m_highlight.

◆ get_icon_texture_id() [1/2]

void * Slic3r::GUI::GLGizmosManager::get_icon_texture_id ( MENU_ICON_NAME icon )

inline

                                                   {
        if (icon_list.find((int)icon) != icon_list.end())
            return icon_list[icon];
        else
            return nullptr;
    }

References icon_list.

Referenced by Slic3r::GUI::GLGizmoUtils::render_tooltip_button(), Slic3r::GUI::GLGizmoUtils::render_video_guide_button(), and Slic3r::GUI::GLGizmoUtils::render_wiki_guide_button().

Here is the caller graph for this function:

◆ get_icon_texture_id() [2/2]

void * Slic3r::GUI::GLGizmosManager::get_icon_texture_id ( MENU_ICON_NAME icon ) const

inline

                                                        {
        if (icon_list.find((int)icon) != icon_list.end())
            return icon_list.at(icon);
        else
            return nullptr;
    }

References icon_list.

◆ get_layout_scale()

float Slic3r::GUI::GLGizmosManager::get_layout_scale ( )

{
    return m_layout.scale;
}

References m_layout.

◆ get_object_manipulation()

GizmoObjectManipulation & Slic3r::GUI::GLGizmosManager::get_object_manipulation ( )

inline

365{ return m_object_manipulation; }

References m_object_manipulation.

◆ get_overlay_state_hash()

size_t Slic3r::GUI::GLGizmosManager::get_overlay_state_hash ( ) const

{
    size_t hash = 0;
    boost::hash_combine(hash, m_enabled);
    boost::hash_combine(hash, (int)m_hover);
    boost::hash_combine(hash, (int)m_current);
    boost::hash_combine(hash, (int)m_highlight.first);
    boost::hash_combine(hash, m_highlight.second);
    return hash;
}

References m_current, m_enabled, m_highlight, and m_hover.

◆ get_scaled_total_height()

float Slic3r::GUI::GLGizmosManager::get_scaled_total_height ( ) const

{
//BBS: GUI refactor: to support top layout
#if BBS_TOOLBAR_ON_TOP
    return 2.0f * m_layout.scaled_border() + m_layout.scaled_icons_size();
#else
    return m_layout.scale * (2.0f * m_layout.border + (float)get_selectable_idxs().size() * m_layout.stride_y() - m_layout.gap_y);
#endif
}

References get_selectable_idxs(), and m_layout.

Referenced by do_render_overlay(), and render_arrow().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_scaled_total_width()

float Slic3r::GUI::GLGizmosManager::get_scaled_total_width ( ) const

{
//BBS: GUI refactor: to support top layout
#if BBS_TOOLBAR_ON_TOP
    return m_layout.scale * (2.0f * m_layout.border + (float)get_selectable_idxs().size() * m_layout.stride_x() - m_layout.gap_x);
#else
    return 2.0f * m_layout.scaled_border() + m_layout.scaled_icons_size();
#endif
}

References get_selectable_idxs(), and m_layout.

Referenced by do_render_overlay().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_selectable_icons_cnt()

int Slic3r::GUI::GLGizmosManager::get_selectable_icons_cnt ( ) const

inline

356{ return get_selectable_idxs().size(); }

References get_selectable_idxs().

Here is the call graph for this function:

◆ get_selectable_idxs()

std::vector< size_t > Slic3r::GUI::GLGizmosManager::get_selectable_idxs ( ) const

private

{
    std::vector<size_t> out;
    out.reserve(m_gizmos.size());
    if (m_parent.get_canvas_type() == GLCanvas3D::CanvasAssembleView) {
        for (size_t i = 0; i < m_gizmos.size(); ++i)
            if (m_gizmos[i]->get_sprite_id() == (unsigned int) Move ||
                m_gizmos[i]->get_sprite_id() == (unsigned int) Rotate ||
                m_gizmos[i]->get_sprite_id() == (unsigned int) Measure ||
                m_gizmos[i]->get_sprite_id() == (unsigned int) Assembly ||
                m_gizmos[i]->get_sprite_id() == (unsigned int) MmSegmentation)
                out.push_back(i);
    }
    else {
        for (size_t i = 0; i < m_gizmos.size(); ++i)
            if (m_gizmos[i]->is_selectable())
                out.push_back(i);
    }
    return out;
}

References Assembly, Slic3r::GUI::GLCanvas3D::CanvasAssembleView, m_gizmos, m_parent, Measure, MmSegmentation, Move, and Rotate.

Referenced by do_render_overlay(), get_gizmo_from_mouse(), get_gizmo_from_name(), get_scaled_total_height(), get_scaled_total_width(), get_selectable_icons_cnt(), and render_arrow().

Here is the caller graph for this function:

◆ get_tooltip()

std::string Slic3r::GUI::GLGizmosManager::get_tooltip ( ) const

{
    if (!m_tooltip.empty())
        return m_tooltip;
 
    const GLGizmoBase* curr = get_current();
    return (curr != nullptr) ? curr->get_tooltip() : "";
}

References get_current(), Slic3r::GUI::GLGizmoBase::get_tooltip(), and m_tooltip.

Here is the call graph for this function:

◆ get_uniform_scaling()

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

inline

366{ return m_object_manipulation.get_uniform_scaling();}

References m_object_manipulation.

◆ gizmo_event()

bool Slic3r::GUI::GLGizmosManager::gizmo_event	(	SLAGizmoEventType	action,
		const Vec2d &	mouse_position = Vec2d::Zero(),
		bool	shift_down = false,
		bool	alt_down = false,
		bool	control_down = false )

private

{
    if (!m_enabled || m_gizmos.empty())
        return false;
 
    /*if (m_current == SlaSupports)
        return dynamic_cast<GLGizmoSlaSupports*>(m_gizmos[SlaSupports].get())->gizmo_event(action, mouse_position, shift_down, alt_down, control_down);
    else if (m_current == Hollow)
        return dynamic_cast<GLGizmoHollow*>(m_gizmos[Hollow].get())->gizmo_event(action, mouse_position, shift_down, alt_down, control_down);
    else*/ if (m_current == FdmSupports)
        return dynamic_cast<GLGizmoFdmSupports*>(m_gizmos[FdmSupports].get())->gizmo_event(action, mouse_position, shift_down, alt_down, control_down);
    else if (m_current == Seam)
        return dynamic_cast<GLGizmoSeam*>(m_gizmos[Seam].get())->gizmo_event(action, mouse_position, shift_down, alt_down, control_down);
    else if (m_current == MmSegmentation)
        return dynamic_cast<GLGizmoMmuSegmentation*>(m_gizmos[MmSegmentation].get())->gizmo_event(action, mouse_position, shift_down, alt_down, control_down);
    else if (m_current == Measure)
        return dynamic_cast<GLGizmoMeasure *>(m_gizmos[Measure].get())->gizmo_event(action, mouse_position, shift_down, alt_down, control_down);
    else if (m_current == Assembly)
        return dynamic_cast<GLGizmoAssembly *>(m_gizmos[Assembly].get())->gizmo_event(action, mouse_position, shift_down, alt_down, control_down);
    else if (m_current == Cut)
        return dynamic_cast<GLGizmoCut3D*>(m_gizmos[Cut].get())->gizmo_event(action, mouse_position, shift_down, alt_down, control_down);
    else if (m_current == FuzzySkin)
        return dynamic_cast<GLGizmoFuzzySkin*>(m_gizmos[FuzzySkin].get())->gizmo_event(action, mouse_position, shift_down, alt_down, control_down);
    else if (m_current == TextureDisplacement)
        return dynamic_cast<GLGizmoTextureDisplacement*>(m_gizmos[TextureDisplacement].get())->gizmo_event(action, mouse_position, shift_down, alt_down, control_down);
    else if (m_current == MeshBoolean)
        return dynamic_cast<GLGizmoMeshBoolean*>(m_gizmos[MeshBoolean].get())->gizmo_event(action, mouse_position, shift_down, alt_down, control_down);
    else if (m_current == BrimEars)
        return dynamic_cast<GLGizmoBrimEars*>(m_gizmos[BrimEars].get())->gizmo_event(action, mouse_position, shift_down, alt_down, control_down);
    else
        return false;
}

References Assembly, BrimEars, Cut, FdmSupports, FuzzySkin, Slic3r::GUI::GLGizmoBrimEars::gizmo_event(), Slic3r::GUI::GLGizmoCut3D::gizmo_event(), Slic3r::GUI::GLGizmoMeasure::gizmo_event(), Slic3r::GUI::GLGizmoMeshBoolean::gizmo_event(), Slic3r::GUI::GLGizmoPainterBase::gizmo_event(), m_current, m_enabled, m_gizmos, Measure, MeshBoolean, MmSegmentation, Seam, and TextureDisplacement.

Referenced by on_char(), on_delete_key(), on_key(), and on_mouse_wheel().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ gizmos_toolbar_on_mouse()

bool Slic3r::GUI::GLGizmosManager::gizmos_toolbar_on_mouse ( const wxMouseEvent & mouse_event )

private

Process mouse event on gizmo toolbar.

Parameters

mouse_event Event descriptor

Returns: TRUE when take responsibility for event otherwise FALSE. On true, event should not be process by others. On false, event should be process by others.

                                                                             {
    assert(m_enabled);
    // keep information about events to process
    struct MouseCapture
    {
        bool left = false;
        bool middle = false;
        bool right  = false;
        bool exist_tooltip = false;
        MouseCapture() = default;
        bool any() const { return left || middle || right; }
        void reset() {
            left   = false;
            middle = false;
            right  = false;
        }
    };
    static MouseCapture mc;
 
    // wxCoord == int --> wx/types.h
    Vec2i32 mouse_coord(mouse_event.GetX(), mouse_event.GetY());
    Vec2d mouse_pos = mouse_coord.cast<double>();
 
    EType gizmo = get_gizmo_from_mouse(mouse_pos);
    bool  selected_gizmo = gizmo != Undefined;
 
    // fast reaction on move mouse
    if (mouse_event.Moving()) {
        assert(!mc.any());
        if (selected_gizmo) {
            mc.exist_tooltip = true;
            update_hover_state(gizmo);
            // at this moment is enebled to process mouse move under gizmo
            // tools bar e.g. Do not interupt dragging. 
            return false;
        } else if (mc.exist_tooltip) {
            // first move out of gizmo tool bar - unselect tooltip
            mc.exist_tooltip = false;
            update_hover_state(Undefined);
            return false;
        }
        return false;
    }
 
    if (selected_gizmo) {
        // mouse is above toolbar
        if (mouse_event.LeftDown() || mouse_event.LeftDClick()) {
            mc.left = true;
            if (gizmo == Emboss) {
                GLGizmoBase *gizmo_emboss = m_gizmos[Emboss].get();
                dynamic_cast<GLGizmoEmboss *>(gizmo_emboss)->on_shortcut_key();
            } else {
                open_gizmo(gizmo);
            }
            return true;
        }
        else if (mouse_event.RightDown()) {
            mc.right  = true;
            return true;
        }
        else if (mouse_event.MiddleDown()) {
            mc.middle = true;
            return true;
        }
    }
 
    if (mc.any()) {
        // Check if exist release of event started above toolbar?
        if (mouse_event.Dragging()) {
            if (!selected_gizmo && mc.exist_tooltip) {
                // dragging out of gizmo let tooltip disapear
                mc.exist_tooltip = false;
                update_hover_state(Undefined);
            }
            // draging start on toolbar so no propagation into scene
            return true;
        }
        else if (mc.left && mouse_event.LeftUp()) {
            mc.left = false;
            return true;
        }
        else if (mc.right && mouse_event.RightUp()) {
            mc.right = false;
            return true;
        }
        else if (mc.middle && mouse_event.MiddleUp()) {
            mc.middle = false;
            return true;
        }
    
        // event out of window is not porocessed
        // left down on gizmo -> keep down -> move out of window -> release left
        if (mouse_event.Leaving()) mc.reset();
    }
    return false;
}

References Emboss, get_gizmo_from_mouse(), m_enabled, m_gizmos, open_gizmo(), Undefined, update_hover_state(), and Slic3r::GUI::wxMouseEvent.

Referenced by on_mouse().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ grabber_contains_mouse()

bool Slic3r::GUI::GLGizmosManager::grabber_contains_mouse ( ) const

private

{
    if (!m_enabled)
        return false;
 
    GLGizmoBase* curr = get_current();
    return (curr != nullptr) ? (curr->get_hover_id() != -1) : false;
}

References get_current(), Slic3r::GUI::GLGizmoBase::get_hover_id(), and m_enabled.

Here is the call graph for this function:

◆ id()

ObjectID Slic3r::ObjectBase::id ( ) const

inlineinherited

69{ return m_id; }

References m_id.

◆ init()

bool Slic3r::GUI::GLGizmosManager::init ( )

{
    if (!m_gizmos.empty())
        return true;
    init_icon_textures();
 
    m_background_texture.metadata.filename = m_is_dark ? "toolbar_background_dark.png" : "toolbar_background.png";
    m_background_texture.metadata.left = 16;
    m_background_texture.metadata.top = 16;
    m_background_texture.metadata.right = 16;
    m_background_texture.metadata.bottom = 16;
 
    if (!m_background_texture.metadata.filename.empty())
    {
        if (!m_background_texture.texture.load_from_file(resources_dir() + "/images/" + m_background_texture.metadata.filename, false, GLTexture::SingleThreaded, false))
            return false;
    }
 
    // Order of gizmos in the vector must match order in EType!
    //BBS: GUI refactor: add obj manipulation
    m_gizmos.clear();
    unsigned int sprite_id = 0;
    m_gizmos.emplace_back(new GLGizmoMove3D(m_parent, m_is_dark ? "toolbar_move_dark.svg" : "toolbar_move.svg", EType::Move, &m_object_manipulation));
    m_gizmos.emplace_back(new GLGizmoRotate3D(m_parent, m_is_dark ? "toolbar_rotate_dark.svg" : "toolbar_rotate.svg", EType::Rotate, &m_object_manipulation));
    m_gizmos.emplace_back(new GLGizmoScale3D(m_parent, m_is_dark ? "toolbar_scale_dark.svg" : "toolbar_scale.svg", EType::Scale, &m_object_manipulation));
    m_gizmos.emplace_back(new GLGizmoFlatten(m_parent, m_is_dark ? "toolbar_flatten_dark.svg" : "toolbar_flatten.svg", EType::Flatten));
    m_gizmos.emplace_back(new GLGizmoCut3D(m_parent, m_is_dark ? "toolbar_cut_dark.svg" : "toolbar_cut.svg", EType::Cut));
    m_gizmos.emplace_back(new GLGizmoMeshBoolean(m_parent, m_is_dark ? "toolbar_meshboolean_dark.svg" : "toolbar_meshboolean.svg", EType::MeshBoolean));
    m_gizmos.emplace_back(new GLGizmoFdmSupports(m_parent, m_is_dark ? "toolbar_support_dark.svg" : "toolbar_support.svg", EType::FdmSupports));
    m_gizmos.emplace_back(new GLGizmoSeam(m_parent, m_is_dark ? "toolbar_seam_dark.svg" : "toolbar_seam.svg", EType::Seam));
    m_gizmos.emplace_back(new GLGizmoFuzzySkin(m_parent, m_is_dark ? "toolbar_fuzzy_skin_paint_dark.svg" : "toolbar_fuzzy_skin_paint.svg", EType::FuzzySkin));
    m_gizmos.emplace_back(new GLGizmoMmuSegmentation(m_parent, m_is_dark ? "mmu_segmentation_dark.svg" : "mmu_segmentation.svg", EType::MmSegmentation));
    // One shared icon (no dedicated dark variant yet); it recolours acceptably in both themes.
    m_gizmos.emplace_back(new GLGizmoTextureDisplacement(m_parent, "toolbar_texture_displacement.svg", EType::TextureDisplacement));
    m_gizmos.emplace_back(new GLGizmoEmboss(m_parent, m_is_dark ? "toolbar_text_dark.svg" : "toolbar_text.svg", EType::Emboss));
    m_gizmos.emplace_back(new GLGizmoSVG(m_parent));
    m_gizmos.emplace_back(new GLGizmoMeasure(m_parent, m_is_dark ? "toolbar_measure_dark.svg" : "toolbar_measure.svg", EType::Measure));
    m_gizmos.emplace_back(new GLGizmoAssembly(m_parent, m_is_dark ? "toolbar_assembly_dark.svg" : "toolbar_assembly.svg", EType::Assembly));
    m_gizmos.emplace_back(new GLGizmoSimplify(m_parent, "reduce_triangles.svg", EType::Simplify));
    m_gizmos.emplace_back(new GLGizmoBrimEars(m_parent, m_is_dark ? "toolbar_brimears_dark.svg" : "toolbar_brimears.svg", EType::BrimEars));
    //m_gizmos.emplace_back(new GLGizmoSlaSupports(m_parent, "sla_supports.svg", sprite_id++));
    //m_gizmos.emplace_back(new GLGizmoFaceDetector(m_parent, "face recognition.svg", sprite_id++));
    //m_gizmos.emplace_back(new GLGizmoHollow(m_parent, "hollow.svg", sprite_id++));
 
    m_common_gizmos_data.reset(new CommonGizmosDataPool(&m_parent));
 
    for (auto& gizmo : m_gizmos) {
        if (! gizmo->init()) {
            m_gizmos.clear();
            return false;
        }
        gizmo->set_common_data_pool(m_common_gizmos_data.get());
        gizmo->on_change_color_mode(m_is_dark);
    }
 
    m_current = Undefined;
    m_hover = Undefined;
    m_highlight = std::pair<EType, bool>(Undefined, false);
 
    return true;
}

References Assembly, BrimEars, Cut, Emboss, FdmSupports, Flatten, FuzzySkin, init_icon_textures(), m_background_texture, m_common_gizmos_data, m_current, m_gizmos, m_highlight, m_hover, m_is_dark, m_object_manipulation, m_parent, Measure, MeshBoolean, MmSegmentation, Move, Slic3r::resources_dir(), Rotate, Scale, Seam, Simplify, Slic3r::GUI::GLTexture::SingleThreaded, TextureDisplacement, and Undefined.

Here is the call graph for this function:

◆ init_arrow()

bool Slic3r::GUI::GLGizmosManager::init_arrow ( const std::string & filename )

{
    if (m_arrow_texture.get_id() != 0)
        return true;
 
    const std::string path = resources_dir() + "/images/";
    return (!filename.empty()) ? m_arrow_texture.load_from_svg_file(path + filename, false, false, false, 1000) : false;
}

References m_arrow_texture, and Slic3r::resources_dir().

Here is the call graph for this function:

◆ init_icon_textures()

bool Slic3r::GUI::GLGizmosManager::init_icon_textures ( )

{
    if (icon_list.size() > 0) {
        return true;
    }
    ImTextureID texture_id;
 
    icon_list.clear();
    if (IMTexture::load_from_svg_file(Slic3r::resources_dir() + "/images/toolbar_reset.svg", 16, 16, texture_id))
        icon_list.insert(std::make_pair((int)IC_TOOLBAR_RESET, texture_id));
    else
        return false;
 
    if (IMTexture::load_from_svg_file(Slic3r::resources_dir() + "/images/toolbar_reset_hover.svg", 16, 16, texture_id))
        icon_list.insert(std::make_pair((int)IC_TOOLBAR_RESET_HOVER, texture_id));
    else
        return false;
 
    if (IMTexture::load_from_svg_file(Slic3r::resources_dir() + "/images/toolbar_reset_zero.svg", 16, 16, texture_id))
        icon_list.insert(std::make_pair((int) IC_TOOLBAR_RESET_ZERO, texture_id));
    else
        return false;
 
    if (IMTexture::load_from_svg_file(Slic3r::resources_dir() + "/images/toolbar_reset_zero_hover.svg", 16, 16, texture_id))
        icon_list.insert(std::make_pair((int) IC_TOOLBAR_RESET_ZERO_HOVER, texture_id));
    else
        return false;
 
    if (IMTexture::load_from_svg_file(Slic3r::resources_dir() + "/images/toolbar_tooltip.svg", 15, 15, texture_id)) // ORCA: Use same resolution with gizmos to prevent blur on icon
        icon_list.insert(std::make_pair((int)IC_TOOLBAR_TOOLTIP, texture_id));
    else
        return false;
 
    if (IMTexture::load_from_svg_file(Slic3r::resources_dir() + "/images/toolbar_wiki.svg", 15, 15, texture_id))
        icon_list.insert(std::make_pair((int)IC_TOOLBAR_WIKI_GUIDE, texture_id));
    else
        return false;
 
    if (IMTexture::load_from_svg_file(Slic3r::resources_dir() + "/images/toolbar_video_guide.svg", 15, 15, texture_id))
        icon_list.insert(std::make_pair((int)IC_TOOLBAR_VIDEO_GUIDE, texture_id));
    else
        return false;
 
    if (IMTexture::load_from_svg_file(Slic3r::resources_dir() + "/images/canvas_menu.svg", 72, 72, texture_id))
        icon_list.insert(std::make_pair((int) IC_CANVAS_MENU, texture_id));
    else
        return false;
 
    if (IMTexture::load_from_svg_file(Slic3r::resources_dir() + "/images/canvas_menu_hover.svg", 72, 72, texture_id))
        icon_list.insert(std::make_pair((int) IC_CANVAS_MENU_HOVER, texture_id));
    else
        return false;
 
    if (IMTexture::load_from_svg_file(Slic3r::resources_dir() + "/images/canvas_menu_dark.svg", 72, 72, texture_id))
        icon_list.insert(std::make_pair((int) IC_CANVAS_MENU_DARK, texture_id));
    else
        return false;
 
    if (IMTexture::load_from_svg_file(Slic3r::resources_dir() + "/images/canvas_menu_dark_hover.svg", 72, 72, texture_id))
        icon_list.insert(std::make_pair((int) IC_CANVAS_MENU_DARK_HOVER, texture_id));
    else
        return false;
 
    if (IMTexture::load_from_svg_file(Slic3r::resources_dir() + "/images/canvas_zoom.svg", 72, 72, texture_id))
        icon_list.insert(std::make_pair((int) IC_CANVAS_ZOOM, texture_id));
    else
        return false;
 
    if (IMTexture::load_from_svg_file(Slic3r::resources_dir() + "/images/canvas_zoom_hover.svg", 72, 72, texture_id))
        icon_list.insert(std::make_pair((int) IC_CANVAS_ZOOM_HOVER, texture_id));
    else
        return false;
 
    if (IMTexture::load_from_svg_file(Slic3r::resources_dir() + "/images/canvas_zoom_dark.svg", 72, 72, texture_id))
        icon_list.insert(std::make_pair((int) IC_CANVAS_ZOOM_DARK, texture_id));
    else
        return false;
 
    if (IMTexture::load_from_svg_file(Slic3r::resources_dir() + "/images/canvas_zoom_dark_hover.svg", 72, 72, texture_id))
        icon_list.insert(std::make_pair((int) IC_CANVAS_ZOOM_DARK_HOVER, texture_id));
    else
        return false;
 
    for (const auto& [icon, name] : std::initializer_list<std::pair<MENU_ICON_NAME, const char*>>{
             { IC_CANVAS_SECTION, "canvas_section" }, { IC_CANVAS_SECTION_HOVER, "canvas_section_hover" },
             { IC_CANVAS_SECTION_DARK, "canvas_section_dark" }, { IC_CANVAS_SECTION_DARK_HOVER, "canvas_section_dark_hover" },
             { IC_CANVAS_SECTION_ACTIVE, "canvas_section_active" }, { IC_CANVAS_SECTION_ACTIVE_HOVER, "canvas_section_active_hover" },
             { IC_CANVAS_SECTION_ACTIVE_DARK, "canvas_section_active_dark" }, { IC_CANVAS_SECTION_ACTIVE_DARK_HOVER, "canvas_section_active_dark_hover" } }) {
        if (!IMTexture::load_from_svg_file(Slic3r::resources_dir() + "/images/" + name + ".svg", 72, 72, texture_id))
            return false;
        icon_list.insert(std::make_pair((int) icon, texture_id));
    }
 
    for (const auto& [icon, name] : std::initializer_list<std::pair<MENU_ICON_NAME, const char*>>{
        { IC_ALIGN_X_MIN   , "align_x_min"    }, { IC_ALIGN_X_MIN_DARK   , "align_x_min_dark"    },
        { IC_ALIGN_X_CENTER, "align_x_center" }, { IC_ALIGN_X_CENTER_DARK, "align_x_center_dark" },
        { IC_ALIGN_X_MAX   , "align_x_max"    }, { IC_ALIGN_X_MAX_DARK   , "align_x_max_dark"    },
        { IC_ALIGN_Y_MIN   , "align_y_min"    }, { IC_ALIGN_Y_MIN_DARK   , "align_y_min_dark"    },
        { IC_ALIGN_Y_CENTER, "align_y_center" }, { IC_ALIGN_Y_CENTER_DARK, "align_y_center_dark" },
        { IC_ALIGN_Y_MAX   , "align_y_max"    }, { IC_ALIGN_Y_MAX_DARK   , "align_y_max_dark"    },
        { IC_ALIGN_Z_MIN   , "align_z_min"    }, { IC_ALIGN_Z_MIN_DARK   , "align_z_min_dark"    },
        { IC_ALIGN_Z_CENTER, "align_z_center" }, { IC_ALIGN_Z_CENTER_DARK, "align_z_center_dark" },
        { IC_ALIGN_Z_MAX   , "align_z_max"    }, { IC_ALIGN_Z_MAX_DARK   , "align_z_max_dark"    },
        { IC_DISTRIBUTE_X  , "distribute_x"   }, { IC_DISTRIBUTE_X_DARK  , "distribute_x_dark"   },
        { IC_DISTRIBUTE_Y  , "distribute_y"   }, { IC_DISTRIBUTE_Y_DARK  , "distribute_y_dark"   },
        { IC_DISTRIBUTE_Z  , "distribute_z"   }, { IC_DISTRIBUTE_Z_DARK  , "distribute_z_dark"   }
    }) {
        if (!IMTexture::load_from_svg_file(Slic3r::resources_dir() + "/images/" + name + ".svg", 16, 16, texture_id))
            return false;
        icon_list.insert(std::make_pair((int) icon, texture_id));
    }
 
    return true;
}

References IC_ALIGN_X_CENTER, IC_ALIGN_X_CENTER_DARK, IC_ALIGN_X_MAX, IC_ALIGN_X_MAX_DARK, IC_ALIGN_X_MIN, IC_ALIGN_X_MIN_DARK, IC_ALIGN_Y_CENTER, IC_ALIGN_Y_CENTER_DARK, IC_ALIGN_Y_MAX, IC_ALIGN_Y_MAX_DARK, IC_ALIGN_Y_MIN, IC_ALIGN_Y_MIN_DARK, IC_ALIGN_Z_CENTER, IC_ALIGN_Z_CENTER_DARK, IC_ALIGN_Z_MAX, IC_ALIGN_Z_MAX_DARK, IC_ALIGN_Z_MIN, IC_ALIGN_Z_MIN_DARK, IC_CANVAS_MENU, IC_CANVAS_MENU_DARK, IC_CANVAS_MENU_DARK_HOVER, IC_CANVAS_MENU_HOVER, IC_CANVAS_SECTION, IC_CANVAS_SECTION_ACTIVE, IC_CANVAS_SECTION_ACTIVE_DARK, IC_CANVAS_SECTION_ACTIVE_DARK_HOVER, IC_CANVAS_SECTION_ACTIVE_HOVER, IC_CANVAS_SECTION_DARK, IC_CANVAS_SECTION_DARK_HOVER, IC_CANVAS_SECTION_HOVER, IC_CANVAS_ZOOM, IC_CANVAS_ZOOM_DARK, IC_CANVAS_ZOOM_DARK_HOVER, IC_CANVAS_ZOOM_HOVER, IC_DISTRIBUTE_X, IC_DISTRIBUTE_X_DARK, IC_DISTRIBUTE_Y, IC_DISTRIBUTE_Y_DARK, IC_DISTRIBUTE_Z, IC_DISTRIBUTE_Z_DARK, IC_TOOLBAR_RESET, IC_TOOLBAR_RESET_HOVER, IC_TOOLBAR_RESET_ZERO, IC_TOOLBAR_RESET_ZERO_HOVER, IC_TOOLBAR_TOOLTIP, IC_TOOLBAR_VIDEO_GUIDE, IC_TOOLBAR_WIKI_GUIDE, icon_list, Slic3r::GUI::IMTexture::load_from_svg_file(), and Slic3r::resources_dir().

Referenced by init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_allow_multi_select_parts_or_objects()

bool Slic3r::GUI::GLGizmosManager::is_allow_multi_select_parts_or_objects ( ) const

{
    return m_current == Undefined || m_current == EType::Move;
}

References m_current, Move, and Undefined.

◆ is_allow_select_all()

bool Slic3r::GUI::GLGizmosManager::is_allow_select_all ( )

                                          {
    if (m_current == Undefined || m_current == EType::Move||
        m_current == EType::Rotate ||
        m_current == EType::Scale) {
        return true;
    }
    return false;
}

References m_current, Move, Rotate, Scale, and Undefined.

◆ is_dragging()

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

{
    if (! m_enabled || m_current == Undefined)
        return false;
 
    return m_gizmos[m_current]->is_dragging();
}

References m_current, m_enabled, m_gizmos, and Undefined.

◆ is_enabled()

bool Slic3r::GUI::GLGizmosManager::is_enabled ( ) const

inline

277{ return m_enabled; }

References m_enabled.

◆ is_hiding_instances()

bool Slic3r::GUI::GLGizmosManager::is_hiding_instances ( ) const

{
    return (m_common_gizmos_data
         && m_common_gizmos_data->instances_hider()
         && m_common_gizmos_data->instances_hider()->is_valid());
}

References m_common_gizmos_data.

◆ is_in_editing_mode()

bool Slic3r::GUI::GLGizmosManager::is_in_editing_mode ( bool error_notification = false ) const

{
    /*if (m_current == SlaSupports && dynamic_cast<GLGizmoSlaSupports*>(get_current())->is_in_editing_mode()) {
        return true;
    } else*/ if (m_current == BrimEars) {
        dynamic_cast<GLGizmoBrimEars *>(get_current())->update_model_object();
        return false;
    } else {
        return false;
    }
 
}

References BrimEars, get_current(), and m_current.

Here is the call graph for this function:

◆ is_paint_gizmo()

bool Slic3r::GUI::GLGizmosManager::is_paint_gizmo ( )

{
    return m_current == EType::FdmSupports ||
           m_current == EType::MmSegmentation ||
           m_current == EType::FuzzySkin ||
           m_current == EType::TextureDisplacement ||
           m_current == EType::Seam;
}

References FdmSupports, FuzzySkin, m_current, MmSegmentation, Seam, and TextureDisplacement.

◆ is_running()

bool Slic3r::GUI::GLGizmosManager::is_running ( ) const

{
    if (!m_enabled)
        return false;
 
    //GLGizmoBase* curr = get_current();
    //return (curr != nullptr) ? (curr->get_state() == GLGizmoBase::On) : false;
    return m_current != Undefined;
}

References m_current, m_enabled, and Undefined.

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

Here is the caller graph for this function:

◆ load()

template<class Archive>

void Slic3r::GUI::GLGizmosManager::load ( Archive & ar )

inline

    {
        if (!m_enabled)
            return;
 
        m_serializing = true;
 
        // Following is needed to know which to be turn on, but not actually modify
        // m_current prematurely, so activate_gizmo is not confused.
        EType old_current = m_current;
        ar(m_current);
        EType new_current = m_current;
        m_current = old_current;
 
        // activate_gizmo call sets m_current and calls set_state for the gizmo
        // it does nothing in case the gizmo is already activated
        // it can safely be called for Undefined gizmo
        activate_gizmo(new_current);
        if (m_current != Undefined)
            m_gizmos[m_current]->load(ar);
    }

References activate_gizmo(), m_current, m_enabled, m_gizmos, m_serializing, and Undefined.

Here is the call graph for this function:

◆ load_and_construct()

template<class Archive>

void Slic3r::ObjectBase::load_and_construct	(	Archive &	ar,
		cereal::construct< ObjectBase > &	construct )

inlinestaticprivateinherited

109{ ObjectID id; ar(id); construct(id); }

Slic3r::ObjectBase::id

ObjectID id() const

Definition ObjectID.hpp:69

References id().

Here is the call graph for this function:

◆ on_change_color_mode()

void Slic3r::GUI::GLGizmosManager::on_change_color_mode ( bool is_dark )

                                                       {
    m_is_dark = is_dark;
}

References is_dark(), and m_is_dark.

Here is the call graph for this function:

◆ on_char()

bool Slic3r::GUI::GLGizmosManager::on_char ( wxKeyEvent & evt )

{
    // see include/wx/defs.h enum wxKeyCode
    int keyCode = evt.GetKeyCode();
    int ctrlMask = wxMOD_CONTROL;
 
    bool processed = false;
 
    if ((evt.GetModifiers() & ctrlMask) != 0) {
        switch (keyCode)
        {
#ifdef __APPLE__
        case 'a':
        case 'A':
#else /* __APPLE__ */
        case WXK_CONTROL_A:
#endif /* __APPLE__ */
        {
            //if ((m_current == SlaSupports || m_current == Hollow) && gizmo_event(SLAGizmoEventType::SelectAll))
            //    processed = true;
 
            break;
        }
        }
    }
    else if (!evt.HasModifiers()) {
        switch (keyCode)
        {
        // key ESC
        case WXK_ESCAPE:
        {
            if (m_current != Undefined) {
                if ((m_current == Measure || m_current == Assembly) && gizmo_event(SLAGizmoEventType::Escape)) {
                    // do nothing
                } else
                //if ((m_current != SlaSupports) || !gizmo_event(SLAGizmoEventType::DiscardChanges))
                    reset_all_states();
 
                processed = true;
            }
            break;
        }
        //case WXK_RETURN:
        //{
        //    if ((m_current == SlaSupports) && gizmo_event(SLAGizmoEventType::ApplyChanges))
        //        processed = true;
 
        //    break;
        //}
 
        //case 'r' :
        //case 'R' :
        //{
            //if ((m_current == SlaSupports || m_current == Hollow || m_current == FdmSupports || m_current == Seam || m_current == MmSegmentation || m_current == FuzzySkin) && gizmo_event(SLAGizmoEventType::ResetClippingPlane))
            //    processed = true;
 
            //break;
        //}
 
 
        //case 'A':
        //case 'a':
        //{
        //    if (m_current == SlaSupports)
        //    {
        //        gizmo_event(SLAGizmoEventType::AutomaticGeneration);
        //        // set as processed no matter what's returned by gizmo_event() to avoid the calling canvas to process 'A' as arrange
        //        processed = true;
        //    }
        //    break;
        //}
        //case 'M':
        //case 'm':
        //{
        //    if ((m_current == SlaSupports) && gizmo_event(SLAGizmoEventType::ManualEditing))
        //        processed = true;
 
        //    break;
        //}
        //case 'F':
        //case 'f':
        //{
           /* if (m_current == Scale)
            {
                if (!is_dragging())
                    wxGetApp().plater()->scale_selection_to_fit_print_volume();
 
                processed = true;
            }*/
 
            //break;
        //}
        // BBS: Skip all keys when in gizmo. This is necessary for 3D text tool.
        default:
        {
            //if (is_running() && m_current == EType::Text) {
            //    processed = true;
            //}
            break;
        }
        }
    }
 
    if (processed)
        m_parent.set_as_dirty();
 
    return processed;
}

References Assembly, Slic3r::GUI::Escape, gizmo_event(), m_current, m_parent, Measure, reset_all_states(), and Undefined.

Here is the call graph for this function:

◆ on_delete_key()

bool Slic3r::GUI::GLGizmosManager::on_delete_key ( )

{
    const bool processed = (m_current == Cut || m_current == Measure || m_current == Assembly) && gizmo_event(SLAGizmoEventType::Delete);
    if (processed)
        m_parent.set_as_dirty();
    return processed;
}

References Assembly, Cut, Slic3r::GUI::Delete, gizmo_event(), m_current, m_parent, and Measure.

Here is the call graph for this function:

◆ on_key()

bool Slic3r::GUI::GLGizmosManager::on_key ( wxKeyEvent & evt )

{
    int keyCode = evt.GetKeyCode();
    bool processed = false;
 
    if (evt.GetEventType() == wxEVT_KEY_UP)
    {
        if (/*m_current == SlaSupports || m_current == Hollow ||*/ m_current == BrimEars)
        {
            bool is_editing = true;
            bool is_rectangle_dragging = false;
 
            /*if (m_current == SlaSupports) {
                GLGizmoSlaSupports* gizmo = dynamic_cast<GLGizmoSlaSupports*>(get_current());
                is_editing = gizmo->is_in_editing_mode();
                is_rectangle_dragging = gizmo->is_selection_rectangle_dragging();
            } else*/ if (m_current == BrimEars) {
                GLGizmoBrimEars* gizmo = dynamic_cast<GLGizmoBrimEars*>(get_current());
                is_rectangle_dragging = gizmo->is_selection_rectangle_dragging();
            }
            /*else {
                GLGizmoHollow* gizmo = dynamic_cast<GLGizmoHollow*>(get_current());
                is_rectangle_dragging = gizmo->is_selection_rectangle_dragging();
            }*/
 
            if (keyCode == WXK_SHIFT)
            {
                // shift has been just released - SLA gizmo might want to close rectangular selection.
                if (gizmo_event(SLAGizmoEventType::ShiftUp) || (is_editing && is_rectangle_dragging))
                    processed = true;
            }
            else if (keyCode == WXK_ALT)
            {
                // alt has been just released - SLA gizmo might want to close rectangular selection.
                if (gizmo_event(SLAGizmoEventType::AltUp) || (is_editing && is_rectangle_dragging))
                    processed = true;
            }
            else if (keyCode == WXK_CONTROL) {
                gizmo_event(SLAGizmoEventType::CtrlUp);
            }
        }
        // BBS
        if (m_current == MmSegmentation && keyCode > '0' && keyCode <= '9') {
            // capture number key
            processed = true;
        }
        if (m_current == Measure || m_current == Assembly) {
            if (keyCode == WXK_CONTROL)
                gizmo_event(SLAGizmoEventType::CtrlUp, Vec2d::Zero(), evt.ShiftDown(), evt.AltDown(), evt.CmdDown());
            else if (keyCode == WXK_SHIFT)
                gizmo_event(SLAGizmoEventType::ShiftUp, Vec2d::Zero(), evt.ShiftDown(), evt.AltDown(), evt.CmdDown());
        }
//        if (processed)
//            m_parent.set_cursor(GLCanvas3D::Standard);
    }
    else if (evt.GetEventType() == wxEVT_KEY_DOWN)
    {
        /*if ((m_current == SlaSupports) && ((keyCode == WXK_SHIFT) || (keyCode == WXK_ALT))
          && dynamic_cast<GLGizmoSlaSupports*>(get_current())->is_in_editing_mode())
        {
//            m_parent.set_cursor(GLCanvas3D::Cross);
            processed = true;
        }
        else*/ if  ((m_current == BrimEars) && ((keyCode == WXK_SHIFT) || (keyCode == WXK_ALT)))
        {
            processed = true;
        }
        else if (m_current == Cut)
        {
            auto do_move = [this, &processed](double delta_z) {
                GLGizmoCut3D* cut = dynamic_cast<GLGizmoCut3D*>(get_current());
                cut->shift_cut(delta_z);
                processed = true;
            };
 
            switch (keyCode)
            {
            case WXK_NUMPAD_UP:   case WXK_UP:   { do_move(1.0); break; }
            case WXK_NUMPAD_DOWN: case WXK_DOWN: { do_move(-1.0); break; }
            case WXK_SHIFT :      case WXK_ALT: {
                processed = get_current()->is_in_editing_mode();
            }
            default: { break; }
            }
        }
        else if (m_current == Simplify && keyCode == WXK_ESCAPE) {
            GLGizmoSimplify *simplify = dynamic_cast<GLGizmoSimplify *>(get_current());
            if (simplify != nullptr)
                processed = simplify->on_esc_key_down();
        }
        // BBS
        else if (m_current == MmSegmentation) {
            GLGizmoMmuSegmentation* mmu_seg = dynamic_cast<GLGizmoMmuSegmentation*>(get_current());
            if (mmu_seg != nullptr) {
                if (keyCode >= WXK_NUMPAD0 && keyCode <= WXK_NUMPAD9) {
                    keyCode = keyCode- WXK_NUMPAD0+'0';
                }
                if (keyCode >= '0' && keyCode <= '9') {
                    // The paint palette reaches EXTRUDERS_LIMIT slots (mixed-color filaments take
                    // ordinary slots too), so any leading digit that can start a valid two-digit
                    // number waits briefly for a second one.
                    const int digit        = keyCode - '0';
                    const int shortcut_max = int(GLGizmoMmuSegmentation::EXTRUDERS_LIMIT);
                    auto can_start_two_digit = [](int d) { return d > 0 && d * 10 <= shortcut_max; };
                    auto select = [mmu_seg](int number) { return number > 0 && mmu_seg->on_number_key_down(number); };
 
                    if (m_timer_set_color.IsRunning() && m_pending_color_shortcut_tens > 0) {
                        const int two_digit = m_pending_color_shortcut_tens * 10 + digit;
                        const int pending   = m_pending_color_shortcut_tens;
                        m_pending_color_shortcut_tens = 0;
                        m_timer_set_color.Stop();
                        if (two_digit <= shortcut_max) {
                            processed = select(two_digit);
                        } else {
                            // Out of range: commit the pending digit, then treat this one as new input.
                            processed = select(pending);
                            if (can_start_two_digit(digit)) {
                                m_pending_color_shortcut_tens = digit;
                                m_timer_set_color.StartOnce(500);
                                processed = true;
                            } else {
                                processed = select(digit) || processed;
                            }
                        }
                    }
                    else if (can_start_two_digit(digit)) {
                        m_pending_color_shortcut_tens = digit;
                        m_timer_set_color.StartOnce(500);
                        processed = true;
                    }
                    else {
                        processed = select(digit);
                    }
                }
            }
        }
        else if (m_current == Measure || m_current == Assembly) {
            if (keyCode == WXK_CONTROL)
                gizmo_event(SLAGizmoEventType::CtrlDown, Vec2d::Zero(), evt.ShiftDown(), evt.AltDown(), evt.CmdDown());
            else if (keyCode == WXK_SHIFT)
                gizmo_event(SLAGizmoEventType::ShiftDown, Vec2d::Zero(), evt.ShiftDown(), evt.AltDown(), evt.CmdDown());
        }
 
        if (!processed) {
            if (auto painter = dynamic_cast<GLGizmoPainterBase*>(get_current()); painter != nullptr) {
                const std::optional<Shortcut> shortcut = wxGetApp().shortcuts().lookup(ShortcutContext::Painting, KeyChord::from_event(evt));
                processed = shortcut.has_value() && painter->on_tool_shortcut(*shortcut);
                if (processed)
                    // force extra frame to automatically update window size
                    wxGetApp().imgui()->set_requires_extra_frame();
            }
        }
    }
 
    if (processed)
        m_parent.set_as_dirty();
 
    return processed;
}

References Slic3r::GUI::AltUp, Assembly, BrimEars, Slic3r::GUI::CtrlDown, Slic3r::GUI::CtrlUp, Cut, Slic3r::GUI::GLGizmoMmuSegmentation::EXTRUDERS_LIMIT, Slic3r::GUI::KeyChord::from_event(), get_current(), gizmo_event(), Slic3r::GUI::GLGizmoBase::is_in_editing_mode(), Slic3r::GUI::GLGizmoBrimEars::is_selection_rectangle_dragging(), m_current, m_parent, m_pending_color_shortcut_tens, m_timer_set_color, Measure, MmSegmentation, Slic3r::GUI::GLGizmoMmuSegmentation::on_number_key_down(), Slic3r::GUI::Painting, Slic3r::GUI::GLGizmoCut3D::shift_cut(), Slic3r::GUI::ShiftDown, Slic3r::GUI::ShiftUp, and Simplify.

Here is the call graph for this function:

◆ on_mouse()

bool Slic3r::GUI::GLGizmosManager::on_mouse ( const wxMouseEvent & mouse_event )

{
    if (!m_enabled) return false;
 
    // tool bar wants to use event?
    if (gizmos_toolbar_on_mouse(mouse_event)) return true;
 
    // current gizmo wants to use event?
    if (m_current != Undefined &&
        // check if gizmo override method could be slower than simple call virtual function
        // &m_gizmos[m_current]->on_mouse != &GLGizmoBase::on_mouse &&
        m_gizmos[m_current]->on_mouse(mouse_event))
        return true;
 
    if (mouse_event.RightUp() && m_current != EType::Undefined && !m_parent.is_mouse_dragging()) {
        // Prevent default right context menu in gizmos
        return true;
    }
        
    return false;
}

References gizmos_toolbar_on_mouse(), m_current, m_enabled, m_gizmos, m_parent, on_mouse(), Undefined, 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_wheel()

bool Slic3r::GUI::GLGizmosManager::on_mouse_wheel ( const wxMouseEvent & evt )

{
    bool processed = false;
 
    if (/*m_current == SlaSupports || m_current == Hollow ||*/ m_current == FdmSupports || m_current == Seam || m_current == MmSegmentation || m_current == FuzzySkin || m_current == BrimEars) {
        float rot = (float)evt.GetWheelRotation() / (float)evt.GetWheelDelta();
        if (gizmo_event((rot > 0.f ? SLAGizmoEventType::MouseWheelUp : SLAGizmoEventType::MouseWheelDown), Vec2d::Zero(), evt.ShiftDown(), evt.AltDown()
            // BBS
#ifdef __WXOSX_MAC__
            , evt.RawControlDown()
#else
            , evt.ControlDown()
#endif
            ))
            processed = true;
    }
 
    return processed;
}

References BrimEars, FdmSupports, FuzzySkin, gizmo_event(), m_current, MmSegmentation, Slic3r::GUI::MouseWheelDown, Slic3r::GUI::MouseWheelUp, Seam, and Slic3r::GUI::wxMouseEvent.

Here is the call graph for this function:

◆ on_set_color_timer()

void Slic3r::GUI::GLGizmosManager::on_set_color_timer ( wxTimerEvent & evt )

private

{
    // No second digit arrived in time: commit the pending leading digit on its own.
    if (m_current == MmSegmentation && m_pending_color_shortcut_tens > 0) {
        GLGizmoMmuSegmentation* mmu_seg = dynamic_cast<GLGizmoMmuSegmentation*>(get_current());
        if (mmu_seg != nullptr) {
            mmu_seg->on_number_key_down(m_pending_color_shortcut_tens);
            m_parent.set_as_dirty();
        }
    }
    m_pending_color_shortcut_tens = 0;
}

References get_current(), m_current, m_parent, m_pending_color_shortcut_tens, MmSegmentation, and Slic3r::GUI::GLGizmoMmuSegmentation::on_number_key_down().

Referenced by GLGizmosManager().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ open_gizmo()

bool Slic3r::GUI::GLGizmosManager::open_gizmo ( EType type )

{
    if (m_gizmos.empty())
        return false;
 
    int idx = static_cast<int>(type);
 
    // re-open same type cause closing
    if (m_current == type) type = Undefined;
 
    if (m_gizmos[idx]->is_activable() && activate_gizmo(type)) {
        // remove update data into gizmo itself
        update_data();
#ifdef __WXOSX__
        m_parent.post_event(SimpleEvent(wxEVT_PAINT));
#endif
        return true;
    }
    return false;
}

References activate_gizmo(), m_current, m_gizmos, m_parent, Undefined, and update_data().

Referenced by Slic3r::GUI::MenuFactory::append_menu_item_edit_svg(), Slic3r::GUI::MenuFactory::append_menu_item_edit_text(), Slic3r::GUI::GLGizmoSimplify::close(), anonymous_namespace{EmbossJob.cpp}::create_volume(), anonymous_namespace{EmbossJob.cpp}::CreateObjectJob::finalize(), gizmos_toolbar_on_mouse(), Slic3r::GUI::ObjectList::list_manipulation(), Slic3r::GUI::ObjectList::OnEditingStarted(), open_gizmo_by_shortcut(), Slic3r::GUI::ObjectList::part_selection_changed(), reset_all_states(), and Slic3r::GUI::ObjectList::simplify().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ open_gizmo_by_shortcut()

bool Slic3r::GUI::GLGizmosManager::open_gizmo_by_shortcut ( Shortcut shortcut )

{
    if (!m_enabled || m_gizmos.empty())
        return false;
 
    // The text tool opens without a selection because it creates its own object.
    if (GLGizmoBase* gizmo_emboss = m_gizmos[Emboss].get(); gizmo_emboss->shortcut() == shortcut) {
        dynamic_cast<GLGizmoEmboss *>(gizmo_emboss)->on_shortcut_key();
        return true;
    }
 
    if (m_parent.get_selection().is_empty())
        return false;
 
    auto it = std::find_if(m_gizmos.begin(), m_gizmos.end(), [shortcut](const std::unique_ptr<GLGizmoBase> &gizmo) {
        return gizmo->is_activable() && gizmo->shortcut() == shortcut;
    });
    if (it == m_gizmos.end())
        return false;
 
    return open_gizmo(EType(it - m_gizmos.begin()));
}

References Emboss, m_enabled, m_gizmos, m_parent, and open_gizmo().

Here is the call graph for this function:

◆ refresh_on_off_state()

void Slic3r::GUI::GLGizmosManager::refresh_on_off_state ( )

{
    if (m_serializing || m_current == Undefined || m_gizmos.empty())
        return;
 
    // FS: Why update data after Undefined gizmo activation?
    if (!m_gizmos[m_current]->is_activable() && activate_gizmo(Undefined))
        update_data(); 
}

References activate_gizmo(), m_current, m_gizmos, m_serializing, Undefined, and update_data().

Here is the call graph for this function:

◆ render_arrow()

void Slic3r::GUI::GLGizmosManager::render_arrow	(	const GLCanvas3D &	parent,
		EType	highlighted_type ) const

{
    const std::vector<size_t> selectable_idxs = get_selectable_idxs();
    if (selectable_idxs.empty())
        return;
    float cnv_w = (float)m_parent.get_canvas_size().get_width();
    float inv_zoom = (float)wxGetApp().plater()->get_camera().get_inv_zoom();
    float height = get_scaled_total_height();
    float zoomed_border = m_layout.scaled_border() * inv_zoom;
    float zoomed_top_x = (-0.5f * cnv_w) * inv_zoom;
    float zoomed_top_y = (0.5f * height) * inv_zoom;
    zoomed_top_x += zoomed_border;
    zoomed_top_y -= zoomed_border;
    float icons_size = m_layout.scaled_icons_size();
    float zoomed_icons_size = icons_size * inv_zoom;
    float zoomed_stride_y = m_layout.scaled_stride_y() * inv_zoom;
    for (size_t idx : selectable_idxs)
    {
        if (idx == highlighted_type) {
            int tex_width = m_icons_texture.get_width();
            int tex_height = m_icons_texture.get_height();
            unsigned int tex_id = m_arrow_texture.get_id();
            float inv_tex_width = (tex_width != 0.0f) ? 1.0f / tex_width : 0.0f;
            float inv_tex_height = (tex_height != 0.0f) ? 1.0f / tex_height : 0.0f;
 
            const float left_uv   = 0.0f;
            const float right_uv  = 1.0f;
            const float top_uv    = 1.0f;
            const float bottom_uv = 0.0f;
 
            float arrow_sides_ratio = (float)m_arrow_texture.get_height() / (float)m_arrow_texture.get_width();
 
            GLTexture::render_sub_texture(tex_id, zoomed_top_x + zoomed_icons_size * 1.2f, zoomed_top_x + zoomed_icons_size * 1.2f + zoomed_icons_size * 2.2f * arrow_sides_ratio, zoomed_top_y - zoomed_icons_size * 1.6f , zoomed_top_y + zoomed_icons_size * 0.6f, { { left_uv, bottom_uv }, { left_uv, top_uv }, { right_uv, top_uv }, { right_uv, bottom_uv } });
            break;
        }
        zoomed_top_y -= zoomed_stride_y;
    }
}

References get_scaled_total_height(), get_selectable_idxs(), m_arrow_texture, m_icons_texture, m_layout, m_parent, and Slic3r::GUI::GLTexture::render_sub_texture().

Here is the call graph for this function:

◆ render_background()

void Slic3r::GUI::GLGizmosManager::render_background	(	float	left,
		float	top,
		float	right,
		float	bottom,
		float	border_w,
		float	border_h ) const

private

{
    const unsigned int tex_id = m_background_texture.texture.get_id();
    const float tex_width = float(m_background_texture.texture.get_width());
    const float tex_height = float(m_background_texture.texture.get_height());
    if (tex_id != 0 && tex_width > 0 && tex_height > 0) {
        //BBS: GUI refactor: remove the corners of gizmo
        const float inv_tex_width  = 1.0f / tex_width;
        const float inv_tex_height = 1.0f / tex_height;
 
        const float internal_left_uv   = float(m_background_texture.metadata.left) * inv_tex_width;
        const float internal_right_uv  = 1.0f - float(m_background_texture.metadata.right) * inv_tex_width;
        const float internal_top_uv    = 1.0f - float(m_background_texture.metadata.top) * inv_tex_height;
        const float internal_bottom_uv = float(m_background_texture.metadata.bottom) * inv_tex_height;
 
        GLTexture::render_sub_texture(tex_id, left, right, bottom, top, { { internal_left_uv, internal_bottom_uv }, { internal_right_uv, internal_bottom_uv }, { internal_right_uv, internal_top_uv }, { internal_left_uv, internal_top_uv } });
 
        /*
        const float internal_left   = left + border_w;
        const float internal_right  = right - border_w;
        const float internal_top    = top - border_h;
        const float internal_bottom = bottom + border_h;
 
        // float left_uv = 0.0f;
        const float right_uv = 1.0f;
        const float top_uv = 1.0f;
        const float bottom_uv = 0.0f;
 
        const float internal_left_uv   = float(m_background_texture.metadata.left) * inv_tex_width;
        const float internal_right_uv  = 1.0f - float(m_background_texture.metadata.right) * inv_tex_width;
        const float internal_top_uv    = 1.0f - float(m_background_texture.metadata.top) * inv_tex_height;
        const float internal_bottom_uv = float(m_background_texture.metadata.bottom) * inv_tex_height;
 
        // top-left corner
        GLTexture::render_sub_texture(tex_id, left, internal_left, internal_top, top, { { internal_left_uv, internal_bottom_uv }, { internal_right_uv, internal_bottom_uv }, { internal_right_uv, internal_top_uv }, { internal_left_uv, internal_top_uv } });
 
        // top edge
        GLTexture::render_sub_texture(tex_id, internal_left, internal_right, internal_top, top, { { internal_left_uv, internal_top_uv }, { internal_right_uv, internal_top_uv }, { internal_right_uv, top_uv }, { internal_left_uv, top_uv } });
 
        // top-right corner
        GLTexture::render_sub_texture(tex_id, internal_right, right, internal_top, top, { { internal_right_uv, internal_top_uv }, { right_uv, internal_top_uv }, { right_uv, top_uv }, { internal_right_uv, top_uv } });
 
        // center-left edge
        GLTexture::render_sub_texture(tex_id, left, internal_left, internal_bottom, internal_top, { { internal_left_uv, internal_bottom_uv }, { internal_right_uv, internal_bottom_uv }, { internal_right_uv, internal_top_uv }, { internal_left_uv, internal_top_uv } });
 
        // center
        GLTexture::render_sub_texture(tex_id, internal_left, internal_right, internal_bottom, internal_top, { { internal_left_uv, internal_bottom_uv }, { internal_right_uv, internal_bottom_uv }, { internal_right_uv, internal_top_uv }, { internal_left_uv, internal_top_uv } });
 
        // center-right edge
        GLTexture::render_sub_texture(tex_id, internal_right, right, internal_bottom, internal_top, { { internal_right_uv, internal_bottom_uv }, { right_uv, internal_bottom_uv }, { right_uv, internal_top_uv }, { internal_right_uv, internal_top_uv } });
 
        // bottom-left corner
        GLTexture::render_sub_texture(tex_id, left, internal_left, bottom, internal_bottom, { { internal_left_uv, internal_bottom_uv }, { internal_right_uv, internal_bottom_uv }, { internal_right_uv, internal_top_uv }, { internal_left_uv, internal_top_uv } });
 
        // bottom edge
        GLTexture::render_sub_texture(tex_id, internal_left, internal_right, bottom, internal_bottom, { { internal_left_uv, bottom_uv }, { internal_right_uv, bottom_uv }, { internal_right_uv, internal_bottom_uv }, { internal_left_uv, internal_bottom_uv } });
 
        // bottom-right corner
        GLTexture::render_sub_texture(tex_id, internal_right, right, bottom, internal_bottom, { { internal_right_uv, bottom_uv }, { right_uv, bottom_uv }, { right_uv, internal_bottom_uv }, { internal_right_uv, internal_bottom_uv } });
        */
    }
}

References m_background_texture, and Slic3r::GUI::GLTexture::render_sub_texture().

Referenced by do_render_overlay().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ render_current_gizmo()

void Slic3r::GUI::GLGizmosManager::render_current_gizmo ( ) const

{
    if (!m_enabled || m_current == Undefined)
        return;
 
    m_gizmos[m_current]->render();
}

References m_current, m_enabled, m_gizmos, and Undefined.

◆ render_overlay()

void Slic3r::GUI::GLGizmosManager::render_overlay ( )

{
    if (!m_enabled)
        return;
 
    if (m_icons_texture_dirty)
        generate_icons_texture();
 
    do_render_overlay(true);
}

References do_render_overlay(), generate_icons_texture(), m_enabled, and m_icons_texture_dirty.

Here is the call graph for this function:

◆ render_overlay_input_window()

void Slic3r::GUI::GLGizmosManager::render_overlay_input_window ( )

{
    if (!m_enabled)
        return;
 
    do_render_overlay(false);
}

References do_render_overlay(), and m_enabled.

Here is the call graph for this function:

◆ render_painter_gizmo()

void Slic3r::GUI::GLGizmosManager::render_painter_gizmo ( )

{
    // This function shall only be called when current gizmo is
    // derived from GLGizmoPainterBase.
 
    if (!m_enabled || m_current == Undefined)
        return;
 
    auto *gizmo = dynamic_cast<GLGizmoPainterBase*>(get_current());
    assert(gizmo); // check the precondition
    gizmo->render_painter_gizmo();
}

References get_current(), m_current, m_enabled, and Undefined.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reset_all_states()

void Slic3r::GUI::GLGizmosManager::reset_all_states ( )

{
    // The restore/new-project event can run before deferred OpenGL resource
    // loading has populated the gizmo list.  There is nothing to reset until
    // initialization completes.
    if (! m_enabled || m_serializing || m_gizmos.empty())
        return;
 
    const EType current = get_current_type();
    if (current != Undefined)
        // close any open gizmo
        open_gizmo(current);
 
    activate_gizmo(Undefined);
    // Orca: do not clear hover state, as Emboss gizmo can be used without selection
    //m_hover = Undefined;
}

References activate_gizmo(), get_current_type(), m_enabled, m_gizmos, m_serializing, open_gizmo(), and Undefined.

Referenced by Slic3r::GUI::ObjectList::del_info_item(), Slic3r::GUI::ObjectList::list_manipulation(), on_char(), Slic3r::GUI::ObjectList::OnEditingStarted(), and Slic3r::GUI::Plater::priv::set_current_panel().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ save()

template<class Archive>

void Slic3r::GUI::GLGizmosManager::save ( Archive & ar ) const

inline

    {
        if (!m_enabled)
            return;
 
        ar(m_current);
 
        if (m_current != Undefined && !m_gizmos.empty())
            m_gizmos[m_current]->save(ar);
    }

References m_current, m_enabled, m_gizmos, and Undefined.

◆ serialize()

template<class Archive>

void Slic3r::ObjectBase::serialize ( Archive & ar )

inlineprivateinherited

108{ ar(m_id); }

References m_id.

◆ set_enabled()

void Slic3r::GUI::GLGizmosManager::set_enabled ( bool enable )

inline

278{ m_enabled = enable; }

References m_enabled.

◆ set_highlight()

void Slic3r::GUI::GLGizmosManager::set_highlight	(	EType	gizmo,
		bool	highlight_shown )

inline

359{ m_highlight = std::pair<EType, bool>(gizmo, highlight_shown); }

References m_highlight.

◆ set_hover_id()

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

{
  // Measure and assembly handles hover by itself
    if (m_current == EType::Measure || m_current == EType::Assembly) { return; }
    if (!m_enabled || m_current == Undefined)
        return;
 
    m_gizmos[m_current]->set_hover_id(id);
}

References Assembly, m_current, m_enabled, m_gizmos, Measure, and Undefined.

◆ set_icon_dirty()

void Slic3r::GUI::GLGizmosManager::set_icon_dirty ( )

inline

280{ m_icons_texture_dirty = true; }

References m_icons_texture_dirty.

◆ set_invalid_id()

void Slic3r::ObjectBase::set_invalid_id ( )

inlineprotectedinherited

90{ m_id = 0; }

References m_id.

Referenced by Slic3r::CutObjectBase::invalidate().

Here is the caller graph for this function:

◆ set_new_unique_id()

void Slic3r::ObjectBase::set_new_unique_id ( )

inlineprotectedinherited

89{ m_id = generate_new_id(); }

Slic3r::ObjectBase::generate_new_id

static ObjectID generate_new_id()

Definition ObjectID.hpp:100

References generate_new_id(), and m_id.

Referenced by Slic3r::ModelVolume::ModelVolume(), Slic3r::Model::assign_new_unique_ids_recursive(), Slic3r::ModelVolume::assign_new_unique_ids_recursive(), assign_new_unique_ids_recursive(), Slic3r::CutObjectBase::init(), Slic3r::ModelMaterial::set_new_unique_id(), Slic3r::ModelObject::set_new_unique_id(), and Slic3r::ModelVolume::set_new_unique_id().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_overlay_icon_size()

void Slic3r::GUI::GLGizmosManager::set_overlay_icon_size ( float size )

{
    if (m_layout.icons_size != size)
    {
        m_layout.icons_size = size;
        m_icons_texture_dirty = true;
    }
}

References m_icons_texture_dirty, and m_layout.

◆ set_overlay_scale()

void Slic3r::GUI::GLGizmosManager::set_overlay_scale ( float scale )

{
    if (m_layout.scale != scale)
    {
        m_layout.scale = scale;
        m_icons_texture_dirty = true;
    }
}

References m_icons_texture_dirty, m_layout, and scale().

Here is the call graph for this function:

◆ switch_gizmos_icon_filename()

void Slic3r::GUI::GLGizmosManager::switch_gizmos_icon_filename ( )

{
    m_background_texture.metadata.filename = m_is_dark ? "toolbar_background_dark.png" : "toolbar_background.png";
    m_background_texture.metadata.left = 16;
    m_background_texture.metadata.top = 16;
    m_background_texture.metadata.right = 16;
    m_background_texture.metadata.bottom = 16;
    if (!m_background_texture.metadata.filename.empty())
        m_background_texture.texture.load_from_file(resources_dir() + "/images/" + m_background_texture.metadata.filename, false, GLTexture::SingleThreaded, false);
 
    for (auto& gizmo : m_gizmos) {
        gizmo->on_change_color_mode(m_is_dark);
        switch (gizmo->get_sprite_id())
        {
        case(EType::Move):
            gizmo->set_icon_filename(m_is_dark ? "toolbar_move_dark.svg" : "toolbar_move.svg");
            break;
        case(EType::Rotate):
            gizmo->set_icon_filename(m_is_dark ? "toolbar_rotate_dark.svg" : "toolbar_rotate.svg");
            break;
        case(EType::Scale):
            gizmo->set_icon_filename(m_is_dark ? "toolbar_scale_dark.svg" : "toolbar_scale.svg");
            break;
        case(EType::Flatten):
            gizmo->set_icon_filename(m_is_dark ? "toolbar_flatten_dark.svg" : "toolbar_flatten.svg");
            break;
        case(EType::Cut):
            gizmo->set_icon_filename(m_is_dark ? "toolbar_cut_dark.svg" : "toolbar_cut.svg");
            break;
        case(EType::FdmSupports):
            gizmo->set_icon_filename(m_is_dark ? "toolbar_support_dark.svg" : "toolbar_support.svg");
            break;
        case(EType::Seam):
            gizmo->set_icon_filename(m_is_dark ? "toolbar_seam_dark.svg" : "toolbar_seam.svg");
            break;
        case(EType::Emboss):
            gizmo->set_icon_filename(m_is_dark ? "toolbar_text_dark.svg" : "toolbar_text.svg");
            break;
        case(EType::MmSegmentation):
            gizmo->set_icon_filename(m_is_dark ? "mmu_segmentation_dark.svg" : "mmu_segmentation.svg");
            break;
        case(EType::FuzzySkin):
            gizmo->set_icon_filename(m_is_dark ? "toolbar_fuzzy_skin_paint_dark.svg" : "toolbar_fuzzy_skin_paint.svg");
            break;
        case(EType::TextureDisplacement):
            // One shared icon in both themes (no dedicated dark variant yet) - but it must still be
            // *this* gizmo's icon. Handing it the fuzzy-skin one here quietly replaced the icon set at
            // construction, so the toolbar ended up showing two identical fuzzy-skin buttons after any
            // light/dark switch.
            gizmo->set_icon_filename("toolbar_texture_displacement.svg");
            break;
        case(EType::MeshBoolean):
            gizmo->set_icon_filename(m_is_dark ? "toolbar_meshboolean_dark.svg" : "toolbar_meshboolean.svg");
            break;
        case (EType::Measure):
            gizmo->set_icon_filename(m_is_dark ? "toolbar_measure_dark.svg" : "toolbar_measure.svg");
            break;
        case (EType::Assembly):
            gizmo->set_icon_filename(m_is_dark ? "toolbar_assembly_dark.svg" : "toolbar_assembly.svg");
            break;
        case (EType::BrimEars):
            gizmo->set_icon_filename(m_is_dark ? "toolbar_brimears_dark.svg" : "toolbar_brimears.svg");
            break;
        }
 
    }
}

References Assembly, BrimEars, Cut, Emboss, FdmSupports, Flatten, FuzzySkin, m_background_texture, m_gizmos, m_is_dark, Measure, MeshBoolean, MmSegmentation, Move, Slic3r::resources_dir(), Rotate, Scale, Seam, Slic3r::GUI::GLTexture::SingleThreaded, and TextureDisplacement.

Here is the call graph for this function:

◆ timestamp()

virtual Timestamp Slic3r::ObjectBase::timestamp ( ) const

inlinevirtualinherited

Reimplemented in Slic3r::ModelConfigObject, and Slic3r::ObjectWithTimestamp.

74{ return 0; }

◆ update_after_undo_redo()

void Slic3r::GUI::GLGizmosManager::update_after_undo_redo ( const UndoRedo::Snapshot & snapshot )

{
    update_data();
    m_serializing = false;
    // if (m_current == SlaSupports
    //  && snapshot.snapshot_data.flags & UndoRedo::SnapshotData::RECALCULATE_SLA_SUPPORTS)
    //     dynamic_cast<GLGizmoSlaSupports*>(m_gizmos[SlaSupports].get())->reslice_SLA_supports(true);
}

References m_serializing, and update_data().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_data()

void Slic3r::GUI::GLGizmosManager::update_data ( )

Distribute information about different data into active gizmo Should be called when selection changed.

{
    if (!m_enabled) return;
 
    const Selection& selection = m_parent.get_selection();
 
    if (m_common_gizmos_data)
        m_common_gizmos_data->update(get_current()
                                   ? get_current()->get_requirements()
                                   : CommonGizmosDataID(0));
    update_section_view();
    if (m_current != Undefined) m_gizmos[m_current]->data_changed(m_serializing);
 
    // Orca: hack: Fix issue that flatten gizmo faces not updated after reload from disk
    if (m_current != Flatten && !m_gizmos.empty()) m_gizmos[Flatten]->data_changed(m_serializing);
 
    //BBS: GUI refactor: add object manipulation in gizmo
    if (!selection.is_empty()) {
        m_object_manipulation.update_ui_from_settings();
        m_object_manipulation.UpdateAndShow(true);
    }
}

References Flatten, get_current(), Slic3r::GUI::Selection::is_empty(), m_common_gizmos_data, m_current, m_enabled, m_gizmos, m_object_manipulation, m_parent, m_serializing, Undefined, and update_section_view().

Referenced by open_gizmo(), refresh_on_off_state(), Slic3r::GUI::GizmoObjectManipulation::set_coordinates_type(), Slic3r::GUI::Plater::priv::set_current_panel(), and update_after_undo_redo().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_hover_state()

void Slic3r::GUI::GLGizmosManager::update_hover_state ( const EType & type )

private

{
    assert(m_enabled);
    if (type == Undefined) { 
        m_hover = Undefined;
        m_tooltip.clear();
        return;
    }
 
    const GLGizmoBase &hovered_gizmo = *m_gizmos[type];
    m_hover = hovered_gizmo.is_activable() ? type : Undefined;    
    m_tooltip = hovered_gizmo.get_name();
}

References Slic3r::GUI::GLGizmoBase::get_name(), Slic3r::GUI::GLGizmoBase::is_activable(), m_enabled, m_gizmos, m_hover, m_tooltip, and Undefined.

Referenced by gizmos_toolbar_on_mouse().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_section_view()

void Slic3r::GUI::GLGizmosManager::update_section_view ( )

{
    if (m_current != FdmSupports && m_current != Seam && m_current != MmSegmentation && m_current != FuzzySkin && m_current != BrimEars)
        return;
 
    CommonGizmosDataObjects::ObjectClipper* clipper = m_common_gizmos_data ? m_common_gizmos_data->object_clipper() : nullptr;
    if (clipper == nullptr)
        return;
 
    // Brim ears always cut horizontally.
    clipper->set_position_by_ratio(m_parent.get_section_view_ratio(), m_current == BrimEars ? Vec3d::UnitZ() : m_parent.get_section_view_normal());
}

References BrimEars, FdmSupports, FuzzySkin, m_common_gizmos_data, m_current, m_parent, MmSegmentation, Seam, and Slic3r::GUI::CommonGizmosDataObjects::ObjectClipper::set_position_by_ratio().

Referenced by update_data().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ wants_reslice_supports_on_undo()

bool Slic3r::GUI::GLGizmosManager::wants_reslice_supports_on_undo ( ) const

{
    return false;
    // return (m_current == SlaSupports
    //     && dynamic_cast<const GLGizmoSlaSupports*>(m_gizmos.at(SlaSupports).get())->has_backend_supports());
}

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

Here is the caller graph for this function:

Member Data Documentation

◆ Default_Icons_Size

const float Slic3r::GUI::GLGizmosManager::Default_Icons_Size = 64

static

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

◆ icon_list

std::map< int, void * > Slic3r::GUI::GLGizmosManager::icon_list = {}

staticprivate

Referenced by get_icon_texture_id(), get_icon_texture_id(), and init_icon_textures().

◆ m_arrow_texture

GLTexture Slic3r::GUI::GLGizmosManager::m_arrow_texture

private

Referenced by init_arrow(), and render_arrow().

◆ m_background_texture

BackgroundTexture Slic3r::GUI::GLGizmosManager::m_background_texture

private

Referenced by init(), render_background(), and switch_gizmos_icon_filename().

◆ m_common_gizmos_data

std::unique_ptr<CommonGizmosDataPool> Slic3r::GUI::GLGizmosManager::m_common_gizmos_data

private

Referenced by get_clipping_plane(), init(), is_hiding_instances(), update_data(), and update_section_view().

◆ m_current

EType Slic3r::GUI::GLGizmosManager::m_current

private

◆ m_enabled

bool Slic3r::GUI::GLGizmosManager::m_enabled

private

◆ m_gizmos

std::vector<std::unique_ptr<GLGizmoBase> > Slic3r::GUI::GLGizmosManager::m_gizmos

private

◆ m_highlight

std::pair<EType, bool> Slic3r::GUI::GLGizmosManager::m_highlight

private

Referenced by do_render_overlay(), get_highlight_state(), get_overlay_state_hash(), init(), and set_highlight().

◆ m_hover

EType Slic3r::GUI::GLGizmosManager::m_hover

private

Referenced by GLGizmosManager(), do_render_overlay(), get_overlay_state_hash(), init(), and update_hover_state().

◆ m_icons_texture

GLTexture Slic3r::GUI::GLGizmosManager::m_icons_texture

private

Referenced by do_render_overlay(), generate_icons_texture(), and render_arrow().

◆ m_icons_texture_dirty

bool Slic3r::GUI::GLGizmosManager::m_icons_texture_dirty

private

Referenced by GLGizmosManager(), generate_icons_texture(), render_overlay(), set_icon_dirty(), set_overlay_icon_size(), and set_overlay_scale().

◆ m_id

ObjectID Slic3r::ObjectBase::m_id

privateinherited

Referenced by ObjectBase(), ObjectBase(), ObjectBase(), copy_id(), id(), serialize(), set_invalid_id(), and set_new_unique_id().

◆ m_is_dark

bool Slic3r::GUI::GLGizmosManager::m_is_dark = false

private

Referenced by init(), on_change_color_mode(), and switch_gizmos_icon_filename().

◆ m_layout

Layout Slic3r::GUI::GLGizmosManager::m_layout

private

Referenced by do_render_overlay(), generate_icons_texture(), get_gizmo_from_mouse(), get_layout_scale(), get_scaled_total_height(), get_scaled_total_width(), render_arrow(), set_overlay_icon_size(), and set_overlay_scale().

◆ m_object_manipulation

GizmoObjectManipulation Slic3r::GUI::GLGizmosManager::m_object_manipulation

private

Referenced by GLGizmosManager(), get_object_manipulation(), get_uniform_scaling(), init(), and update_data().

◆ m_parent

GLCanvas3D& Slic3r::GUI::GLGizmosManager::m_parent

private

Referenced by GLGizmosManager(), do_render_overlay(), get_gizmo_from_mouse(), get_selectable_idxs(), init(), on_char(), on_delete_key(), on_key(), on_mouse(), on_set_color_timer(), open_gizmo(), open_gizmo_by_shortcut(), render_arrow(), update_data(), and update_section_view().

◆ m_pending_color_shortcut_tens

int Slic3r::GUI::GLGizmosManager::m_pending_color_shortcut_tens = 0

private

Referenced by on_key(), and on_set_color_timer().

◆ m_restore_realistic_view_after_paint

bool Slic3r::GUI::GLGizmosManager::m_restore_realistic_view_after_paint = false

private

Referenced by activate_gizmo().

◆ m_serializing

bool Slic3r::GUI::GLGizmosManager::m_serializing

private

Referenced by GLGizmosManager(), activate_gizmo(), load(), refresh_on_off_state(), reset_all_states(), update_after_undo_redo(), and update_data().

◆ m_timer_set_color

wxTimer Slic3r::GUI::GLGizmosManager::m_timer_set_color

private

Referenced by GLGizmosManager(), and on_key().

◆ m_tooltip

std::string Slic3r::GUI::GLGizmosManager::m_tooltip

private

Referenced by GLGizmosManager(), get_tooltip(), and update_hover_state().

◆ s_last_id

size_t Slic3r::ObjectBase::s_last_id = 0

staticprivateinherited

Referenced by generate_new_id().

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

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

	OrcaSlicer latest OrcaSlicer

Classes

Public Types

Public Member Functions

Static Public Attributes

Protected Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Typedef Documentation

◆ Timestamp

Member Enumeration Documentation

◆ EType

◆ MENU_ICON_NAME

Constructor & Destructor Documentation

◆ GLGizmosManager()

Member Function Documentation

◆ activate_gizmo()

◆ assign_new_unique_ids_recursive()

◆ check_gizmos_closed_except()

◆ copy_id()

◆ do_render_overlay()

◆ generate_icons_texture()

◆ generate_new_id()

◆ get_clipping_plane()

◆ get_current()

◆ get_current_type()

◆ get_gizmo()

◆ get_gizmo_from_mouse()

◆ get_gizmo_from_name()

◆ get_highlight_state()

◆ get_icon_texture_id() [1/2]

◆ get_icon_texture_id() [2/2]

◆ get_layout_scale()

◆ get_object_manipulation()

◆ get_overlay_state_hash()

◆ get_scaled_total_height()

◆ get_scaled_total_width()

◆ get_selectable_icons_cnt()

◆ get_selectable_idxs()

◆ get_tooltip()

◆ get_uniform_scaling()

◆ gizmo_event()

◆ gizmos_toolbar_on_mouse()

◆ grabber_contains_mouse()

◆ id()

◆ init()

◆ init_arrow()

◆ init_icon_textures()

◆ is_allow_multi_select_parts_or_objects()

◆ is_allow_select_all()

◆ is_dragging()

◆ is_enabled()

◆ is_hiding_instances()

◆ is_in_editing_mode()

◆ is_paint_gizmo()

◆ is_running()

◆ load()

◆ load_and_construct()

◆ on_change_color_mode()

◆ on_char()

◆ on_delete_key()

◆ on_key()

◆ on_mouse()

◆ on_mouse_wheel()

◆ on_set_color_timer()

◆ open_gizmo()

◆ open_gizmo_by_shortcut()

◆ refresh_on_off_state()

◆ render_arrow()

◆ render_background()

◆ render_current_gizmo()

◆ render_overlay()

◆ render_overlay_input_window()

◆ render_painter_gizmo()

◆ reset_all_states()

◆ save()

◆ serialize()

◆ set_enabled()