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

Inheritance diagram for Slic3r::GUI::GLGizmoEmboss:

Collaboration diagram for Slic3r::GUI::GLGizmoEmboss:

Classes
struct	Facenames
struct	GuiCfg

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

Public Member Functions
	GLGizmoEmboss (GLCanvas3D &parent, const std::string &icon_filename, unsigned int sprite_id)
bool	create_volume (ModelVolumeType volume_type, const Vec2d &mouse_pos)
	Create new embossed text volume by type on position of mouse.
bool	create_volume (ModelVolumeType volume_type)
	Create new text without given position.
void	on_shortcut_key ()
	Handle pressing of shortcut.
bool	do_mirror (size_t axis)
	Mirroring from object manipulation panel !! Emboss gizmo must be active.
bool	init ()
void	load (cereal::BinaryInputArchive &ar)
void	save (cereal::BinaryOutputArchive &ar) const
std::string	get_name (bool include_shortcut=true) const
EState	get_state () const
void	set_state (EState state)
std::optional< Shortcut >	shortcut () const
const std::string &	get_icon_filename () const
void	set_icon_filename (const std::string &filename)
bool	is_activable () const
bool	is_selectable () const
CommonGizmosDataID	get_requirements () const
virtual bool	render_follows_cursor () const
void	set_common_data_pool (CommonGizmosDataPool *ptr)
virtual bool	apply_clipping_plane ()
unsigned int	get_sprite_id () const
int	get_hover_id () const
void	set_hover_id (int id)
bool	is_dragging () const
bool	update_items_state ()
void	render ()
void	render_input_window (float x, float y, float bottom_limit)
virtual void	on_change_color_mode (bool is_dark)
virtual std::string	get_tooltip () const
	Mouse tooltip text.
int	get_count ()
std::string	get_gizmo_name ()
void	register_raycasters_for_picking ()
void	unregister_raycasters_for_picking ()
virtual bool	is_in_editing_mode () const
virtual bool	is_selection_rectangle_dragging () const

Static Public Member Functions
static bool	re_emboss (const ModelVolume &text, std::shared_ptr< std::atomic< bool > > job_cancel=nullptr)
	Call on change inside of object conatining projected volume.
static void	update_render_colors ()
static void	load_render_colors ()

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

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

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

Private Member Functions
void	volume_transformation_changing ()
void	volume_transformation_changed ()
bool	init_create (ModelVolumeType volume_type)
void	set_volume_by_selection ()
void	reset_volume ()
bool	is_changed_from_default_style ()
void	reset_to_default_style ()
bool	process (bool make_snapshot=true)
void	close ()
void	draw_window (float x, float y)
void	draw_text_input ()
void	draw_model_type ()
void	draw_style_list ()
void	draw_delete_style_button ()
void	draw_style_rename_popup ()
void	draw_style_rename_button ()
void	draw_style_save_button (bool is_modified)
void	draw_style_save_as_popup ()
void	draw_style_add_button ()
void	init_font_name_texture ()
void	draw_font_list_line ()
void	draw_font_list ()
void	draw_height (bool use_inch)
void	draw_depth (bool use_inch)
bool	set_height ()
bool	draw_italic_button ()
bool	draw_bold_button ()
void	draw_advanced ()
bool	select_facename (const wxString &facename)
template<typename T>
bool	rev_input_mm (const std::string &name, T &value, const T default_value, const std::string &undo_tooltip, T step, T step_fast, const char format, bool use_inch, const std::optional< float > &scale) const
template<typename T>
bool	rev_input (const std::string &name, T &value, const T default_value, const std::string &undo_tooltip, T step, T step_fast, const char format, ImGuiInputTextFlags flags=0) const
	Reversible input float with option to restor default value TODO: make more general, static and move to ImGuiWrapper.
bool	rev_checkbox (const std::string &name, bool &value, const bool *default_value, const std::string &undo_tooltip) const
bool	rev_slider (const std::string &name, std::optional< int > &value, const std::optional< int > *default_value, const std::string &undo_tooltip, int v_min, int v_max, const std::string &format, const wxString &tooltip) const
bool	rev_slider (const std::string &name, std::optional< float > &value, const std::optional< float > *default_value, const std::string &undo_tooltip, float v_min, float v_max, const std::string &format, const wxString &tooltip) const
bool	rev_slider (const std::string &name, float &value, const float *default_value, const std::string &undo_tooltip, float v_min, float v_max, const std::string &format, const wxString &tooltip) const
template<typename T, typename Draw>
bool	revertible (const std::string &name, T &value, const T *default_value, const std::string &undo_tooltip, float undo_offset, Draw draw) const
bool	on_mouse_for_rotation (const wxMouseEvent &mouse_event)
bool	on_mouse_for_translate (const wxMouseEvent &mouse_event)
void	on_mouse_change_selection (const wxMouseEvent &mouse_event)
void	create_notification_not_valid_font (const TextConfiguration &tc)
void	create_notification_not_valid_font (const std::string &text)
void	remove_notification_not_valid_font ()
void	reinit_text_lines (unsigned count_lines=0)
void	calculate_scale ()
void	init_icons ()

Static Private Member Functions
static EmbossStyles	create_default_styles ()

Private Attributes
bool	m_is_unknown_font = false
std::unique_ptr< const GuiCfg >	m_gui_cfg
bool	m_is_advanced_edit_style = false
Emboss::StyleManager	m_style_manager
std::unique_ptr< Facenames >	m_face_names
std::string	m_text
bool	m_keep_up = true
ModelVolume *	m_volume = nullptr
ObjectID	m_volume_id
bool	m_text_contain_unknown_glyph = false
std::shared_ptr< std::atomic< bool > >	m_job_cancel = nullptr
TextLinesModel	m_text_lines
GLGizmoRotate	m_rotate_gizmo
std::optional< float >	m_rotate_start_angle
std::optional< SurfaceDrag >	m_surface_drag
RaycastManager	m_raycast_manager
std::optional< float >	m_scale_height
std::optional< float >	m_scale_depth
IconManager	m_icon_manager
IconManager::VIcons	m_icons
std::vector< std::pair< wxString, wxString > >	m_shortcuts
bool	m_dirty { false }
int	count = 0

Static Private Attributes
static const std::string	M_ICON_FILENAME

Detailed Description

Member Enumeration Documentation

◆ EGrabberExtension

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

stronginherited

Enumerator
None
PosX
NegX
PosY
NegY
PosZ
NegZ

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

◆ EState

enum Slic3r::GUI::GLGizmoBase::EState

inherited

Enumerator
Off
On
Num_States

    {
        Off,
        On,
        Num_States
    };

Constructor & Destructor Documentation

◆ GLGizmoEmboss()

GLGizmoEmboss::GLGizmoEmboss	(	GLCanvas3D &	parent,
		const std::string &	icon_filename,
		unsigned int	sprite_id )

explicit

    : GLGizmoBase(parent, icon_filename, sprite_id)
    , m_gui_cfg(nullptr)
    , m_style_manager(m_imgui->get_glyph_ranges(), create_default_styles)
    , m_face_names(std::make_unique<Facenames>())
    , m_rotate_gizmo(parent, GLGizmoRotate::Axis::Z) // grab id = 2 (Z axis)
{
    m_rotate_gizmo.set_group_id(0);
    m_rotate_gizmo.set_force_local_coordinate(true);
    // to use https://fontawesome.com/ (copy & paste) unicode symbols from web
    // paste HEX unicode into notepad move cursor after unicode press [alt] + [x]
}

References Slic3r::GUI::GLGizmoBase::GLGizmoBase(), create_default_styles(), m_face_names, m_gui_cfg, Slic3r::GUI::GLGizmoBase::m_imgui, m_rotate_gizmo, m_style_manager, Slic3r::make_unique(), and Slic3r::Z.

Here is the call graph for this function:

Member Function Documentation

◆ apply_clipping_plane()

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

inlinevirtualinherited

195{ return true; }

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

Here is the caller graph for this function:

◆ calculate_scale()

void GLGizmoEmboss::calculate_scale ( )

private

                                    {
    Transform3d to_world = m_parent.get_selection().get_first_volume()->world_matrix();
    auto to_world_linear = to_world.linear();
    auto calc = [&to_world_linear](const Vec3d &axe, std::optional<float>& scale)->bool {
        Vec3d  axe_world = to_world_linear * axe;
        double norm_sq   = axe_world.squaredNorm();
        if (is_approx(norm_sq, 1.)) {
            if (scale.has_value())
                scale.reset();
            else
                return false;
        } else {
            scale = sqrt(norm_sq);
        }
        return true;
    };
 
    bool exist_change = calc(Vec3d::UnitY(), m_scale_height);
    exist_change |= calc(Vec3d::UnitZ(), m_scale_depth);
 
    // Change of scale has to change font imgui font size
    if (exist_change)
        m_style_manager.clear_imgui_font();
}

References exist_change(), Slic3r::is_approx(), Slic3r::GUI::GLGizmoBase::m_parent, m_scale_depth, m_scale_height, m_style_manager, and scale().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ close()

void GLGizmoEmboss::close ( )

private

{
    // remove volume when text is empty
    if (m_volume != nullptr && 
        m_volume->text_configuration.has_value() &&
        is_text_empty(m_text)) {
        Plater &p = *wxGetApp().plater();
        // is the text object?
        if (m_volume->is_the_only_one_part()) {
            // delete whole object
            p.remove(m_parent.get_selection().get_object_idx());
        } else {
            // delete text volume
            p.remove_selected();
        }
    }
 
    // close gizmo == open it again
    auto& mng = m_parent.get_gizmos_manager();
    if (mng.get_current_type() == GLGizmosManager::Emboss)
        mng.open_gizmo(GLGizmosManager::Emboss);
}

References Slic3r::GUI::GLGizmosManager::Emboss, Slic3r::GUI::GLGizmoBase::m_parent, m_text, m_volume, Slic3r::GUI::Plater::remove(), and Slic3r::GUI::Plater::remove_selected().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ create_default_styles()

EmbossStyles GLGizmoEmboss::create_default_styles ( )

staticprivate

{
    wxFontEnumerator::InvalidateCache();
    wxArrayString facenames = wxFontEnumerator::GetFacenames(Facenames::encoding);
 
    wxFont wx_font_normal = *wxNORMAL_FONT;
#ifdef __APPLE__
    // Set normal font to helvetica when possible
    for (const wxString &facename : facenames) {
        if (facename.IsSameAs("Helvetica")) {
            wx_font_normal = wxFont(wxFontInfo().FaceName(facename).Encoding(Facenames::encoding));
            break;
        }
    }
#endif // __APPLE__
 
    // https://docs.wxwidgets.org/3.0/classwx_font.html
    // Predefined objects/pointers: wxNullFont, wxNORMAL_FONT, wxSMALL_FONT, wxITALIC_FONT, wxSWISS_FONT
    EmbossStyles styles = {
        WxFontUtils::create_emboss_style(wx_font_normal, _u8L("NORMAL")), // wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT)
        WxFontUtils::create_emboss_style(*wxSMALL_FONT, _u8L("SMALL")),  // A font using the wxFONTFAMILY_SWISS family and 2 points smaller than wxNORMAL_FONT.
        WxFontUtils::create_emboss_style(*wxITALIC_FONT, _u8L("ITALIC")), // A font using the wxFONTFAMILY_ROMAN family and wxFONTSTYLE_ITALIC style and of the same size of wxNORMAL_FONT.
        WxFontUtils::create_emboss_style(*wxSWISS_FONT, _u8L("SWISS")),  // A font identic to wxNORMAL_FONT except for the family used which is wxFONTFAMILY_SWISS.
        WxFontUtils::create_emboss_style(wxFont(10, wxFONTFAMILY_MODERN, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_BOLD), _u8L("MODERN")),        
    };
 
    // Not all predefined font for wx must be valid TTF, but at least one style must be loadable
    styles.erase(std::remove_if(styles.begin(), styles.end(), [](const EmbossStyle& style) {
        wxFont wx_font = WxFontUtils::create_wxFont(style);
 
        // check that face name is setabled
        if (style.prop.face_name.has_value()) {
            wxString face_name = wxString::FromUTF8(style.prop.face_name->c_str());
            wxFont wx_font_temp;
            if (!wx_font_temp.SetFaceName(face_name))
                return true;        
        }
 
        // Check that exsit valid TrueType Font for wx font
        return WxFontUtils::create_font_file(wx_font) == nullptr;
        }),styles.end()
    );
 
    // No valid style in defult list
    // at least one style must contain loadable font
    if (styles.empty()) {
        wxFont wx_font;
        for (const wxString &face : facenames) {
            wx_font = wxFont(face);
            if (WxFontUtils::create_font_file(wx_font) != nullptr)
                break;
            wx_font = wxFont(); // NotOk
        }
 
        if (wx_font.IsOk()) {
            // use first alphabetic sorted installed font
            styles.push_back(WxFontUtils::create_emboss_style(wx_font, _u8L("First font")));
        } else {
            // On current OS is not installed any correct TTF font
            // use font packed with OrcaSlicer
            std::string font_path = Slic3r::resources_dir() + "/fonts/HarmonyOS_Sans_SC_Regular.ttf";
            styles.push_back(EmbossStyle{_u8L("Default font"), font_path, EmbossStyle::Type::file_path});
        }
    }
    add_style_for_default_text(styles);
    return styles;
}

References _u8L, Slic3r::GUI::WxFontUtils::create_emboss_style(), Slic3r::GUI::WxFontUtils::create_font_file(), anonymous_namespace{GLGizmoEmboss.cpp}::Facenames::encoding, and style.

Referenced by GLGizmoEmboss(), and re_emboss().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ create_notification_not_valid_font() [1/2]

void GLGizmoEmboss::create_notification_not_valid_font ( const std::string & text )

private

                                                                            {
    // not neccessary, but for sure that old notification doesnt exist
    if (m_is_unknown_font)
        remove_notification_not_valid_font();
    m_is_unknown_font = true;
 
    auto type  = NotificationType::UnknownFont;
    auto level = NotificationManager::NotificationLevel::WarningNotificationLevel;
    auto notification_manager = wxGetApp().plater()->get_notification_manager();
    notification_manager->push_notification(type, level, text);
}

References m_is_unknown_font, remove_notification_not_valid_font(), Slic3r::GUI::UnknownFont, and Slic3r::GUI::NotificationManager::WarningNotificationLevel.

Here is the call graph for this function:

◆ create_notification_not_valid_font() [2/2]

void GLGizmoEmboss::create_notification_not_valid_font ( const TextConfiguration & tc )

private

{
    const EmbossStyle &es = m_style_manager.get_style();
    const auto &face_name_opt = es.prop.face_name;
    const std::string &face_name_3mf = tc.style.prop.face_name.value_or(tc.style.path);
 
    std::optional<std::string> face_name_by_wx;
    if (!face_name_opt.has_value()) {
        const wxFont& wx_font = m_style_manager.get_wx_font();
        if (wx_font.IsOk()) {
            wxString wx_face_name = wx_font.GetFaceName();
            if (!wx_face_name.empty())
                face_name_by_wx = std::string(wx_face_name.ToUTF8().data());
        }
    }
    const std::string &face_name = face_name_opt.value_or(face_name_by_wx.value_or(es.path));
    std::string text =
        GUI::format(_L("Can't load exactly same font (\"%1%\"). "
                       "Application selected a similar one (\"%2%\"). "
                       "You have to specify font for enable edit text."),
                    face_name_3mf, face_name);
    create_notification_not_valid_font(text);
}

References _L, create_notification_not_valid_font(), Slic3r::FontProp::face_name, Slic3r::GUI::format(), m_style_manager, Slic3r::EmbossStyle::path, Slic3r::EmbossStyle::prop, and Slic3r::TextConfiguration::style.

Referenced by create_notification_not_valid_font(), on_render_input_window(), and set_volume_by_selection().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ create_volume() [1/2]

bool GLGizmoEmboss::create_volume ( ModelVolumeType volume_type )

Create new text without given position.

Parameters

volume_type Object part / Negative volume / Modifier

{
    if (!init_create(volume_type))
        return false;
 
    // NOTE: change style manager - be carefull with order changes
    DataBasePtr base = create_emboss_data_base(m_text, m_style_manager, m_text_lines, m_parent.get_selection(), volume_type, m_job_cancel);
    CreateVolumeParams input = create_input(m_parent, m_style_manager.get_style(), m_raycast_manager, volume_type);
    return start_create_volume_without_position(input, std::move(base));
}

References init_create(), m_job_cancel, Slic3r::GUI::GLGizmoBase::m_parent, m_raycast_manager, m_style_manager, m_text, m_text_lines, and Slic3r::GUI::Emboss::start_create_volume_without_position().

Here is the call graph for this function:

◆ create_volume() [2/2]

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

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

Parameters

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

{
    if (!init_create(volume_type))
        return false;
 
    // NOTE: change style manager - be carefull with order changes
    DataBasePtr base = create_emboss_data_base(m_text, m_style_manager, m_text_lines, m_parent.get_selection(), volume_type, m_job_cancel);
    CreateVolumeParams input = create_input(m_parent, m_style_manager.get_style(), m_raycast_manager, volume_type);
    return start_create_volume(input, std::move(base), mouse_pos);
}

References init_create(), m_job_cancel, Slic3r::GUI::GLGizmoBase::m_parent, m_raycast_manager, m_style_manager, m_text, m_text_lines, and Slic3r::GUI::Emboss::start_create_volume().

Referenced by Slic3r::GUI::add_volume_with_gizmo(), and on_shortcut_key().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ data_changed()

void GLGizmoEmboss::data_changed ( bool is_serializing )

overrideprotectedvirtual

Is called when data (Selection) is changed.

Reimplemented from Slic3r::GUI::GLGizmoBase.

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

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

Here is the call graph for this function:

◆ do_mirror()

bool GLGizmoEmboss::do_mirror ( size_t axis )

Mirroring from object manipulation panel !! Emboss gizmo must be active.

Parameters

axis	Axis for mirroring must be one of {0,1,2}

Returns: True on success start job otherwise False

{ 
    // is valid input
    assert(axis < 3);
    if (axis >= 3)
        return false;
 
    // is gizmo opened and initialized?
    assert(m_parent.get_gizmos_manager().get_current_type() == GLGizmosManager::Emboss);
    if (m_parent.get_gizmos_manager().get_current_type() != GLGizmosManager::Emboss)
        return false;
 
    const std::optional<TextConfiguration> &tc = m_volume->text_configuration;
    assert(tc.has_value());
    bool is_per_glyph = tc.has_value()? tc->style.prop.per_glyph : false;
        
    const std::optional<EmbossShape> &es = m_volume->emboss_shape;
    assert(es.has_value());
    bool use_surface = es.has_value()? es->projection.use_surface : false;
    if (!use_surface && !is_per_glyph) {
        // do normal mirror with fix matrix
        Selection &selection = m_parent.get_selection();
        selection.setup_cache();
 
        auto selection_mirror_fnc = [&selection, &axis]() { selection.mirror((Axis) axis, get_drag_transformation_type(selection)); };
        selection_transform(selection, selection_mirror_fnc);
 
        m_parent.do_mirror(L("Set Mirror"));
        wxGetApp().obj_manipul()->UpdateAndShow(true);
        return true;
    }
 
    Vec3d scale = Vec3d::Ones();
    scale[axis] = -1.;
 
    Transform3d tr = m_volume->get_matrix();
    if (es.has_value()) {
        const std::optional<Transform3d> &fix_tr = es->fix_3mf_tr;
        if (fix_tr.has_value())
            tr = tr * (fix_tr->inverse());
    }
 
    // mirror
    tr = tr * Eigen::Scaling(scale);
 
    if (is_per_glyph) { 
        // init textlines before mirroring on mirrored text volume transformation
        ModelVolumePtrs volumes = prepare_volumes_to_slice(*m_volume);
        m_text_lines.init(tr, volumes, m_style_manager, m_text_lines.get_lines().size());
    }
 
    m_volume->set_transformation(tr); 
    // setting to volume is not visible for user(not GLVolume)    
    // NOTE: Staff around volume transformation change is done in job finish
    return process();
}

References Slic3r::GUI::GLGizmosManager::Emboss, Slic3r::GUI::get_drag_transformation_type(), L, Slic3r::GUI::GLGizmoBase::m_parent, m_style_manager, m_text_lines, m_volume, Slic3r::GUI::Selection::mirror(), process(), scale(), Slic3r::GUI::selection_transform(), and Slic3r::GUI::Selection::setup_cache().

Here is the call graph for this function:

◆ do_stop_dragging()

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

protectedinherited

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

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

Referenced by use_grabbers().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ draw_advanced()

void GLGizmoEmboss::draw_advanced ( )

private

{
    const auto &ff = m_style_manager.get_font_file_with_cache();
    if (!ff.has_value()) { 
        ImGui::Text("%s", _u8L("Advanced options cannot be changed for the selected font.\n"
                                   "Select another font.").c_str());
        return;
    }
 
    FontProp &font_prop = m_style_manager.get_font_prop();
    const FontFile::Info &font_info = get_font_info(*ff.font_file, font_prop);
#ifdef SHOW_FONT_FILE_PROPERTY
    ImGui::SameLine();
    int cache_size = ff.has_value()? (int)ff.cache->size() : 0;
    std::string ff_property = 
        "ascent=" + std::to_string(font_info.ascent) +
        ", descent=" + std::to_string(font_info.descent) +
        ", lineGap=" + std::to_string(font_info.linegap) +
        ", unitPerEm=" + std::to_string(font_info.unit_per_em) + 
        ", cache(" + std::to_string(cache_size) + " glyphs)";
    if (font_file->infos.size() > 1) { 
        unsigned int collection = current_prop.collection_number.value_or(0);
        ff_property += ", collect=" + std::to_string(collection+1) + "/" + std::to_string(font_file->infos.size());
    }
    m_imgui->text_colored(ImGuiWrapper::COL_GREY_DARK, ff_property);
#endif // SHOW_FONT_FILE_PROPERTY
 
    ImGui::Spacing();
 
    auto &tr = m_gui_cfg->translations;
 
    const StyleManager::Style *stored_style = nullptr;
    if (m_style_manager.exist_stored_style())
        stored_style = m_style_manager.get_stored_style();
    
    bool is_the_only_one_part = m_volume->is_the_only_one_part();
    bool can_use_surface = (m_volume->emboss_shape->projection.use_surface)? true : // already used surface must have option to uncheck
                            !is_the_only_one_part;
    m_imgui->disabled_begin(!can_use_surface);
    const bool *def_use_surface = stored_style ?
        &stored_style->projection.use_surface : nullptr;
    StyleManager::Style &current_style = m_style_manager.get_style();
    bool &use_surface = current_style.projection.use_surface;
    if (rev_checkbox(tr.use_surface, use_surface, def_use_surface,
                     _u8L("Revert using of model surface."))) {
        if (use_surface)
            // when using surface distance is not used
            current_style.distance.reset();        
        process();
    }
    m_imgui->disabled_end(); // !can_use_surface
 
    bool &per_glyph = font_prop.per_glyph;
    bool can_use_per_glyph = (per_glyph) ? true : // already used surface must have option to uncheck
                            !is_the_only_one_part;
    m_imgui->disabled_begin(!can_use_per_glyph);
    const bool *def_per_glyph = stored_style ? &stored_style->prop.per_glyph : nullptr;
    if (rev_checkbox(tr.per_glyph, per_glyph, def_per_glyph,
        _u8L("Revert Transformation per glyph."))) {
        if (per_glyph && !m_text_lines.is_init())
            reinit_text_lines();
        process();
    } else if (ImGui::IsItemHovered()) {
        if (per_glyph) {
            m_imgui->tooltip(_u8L("Set global orientation for whole text."), m_gui_cfg->max_tooltip_width);
        } else {
            m_imgui->tooltip(_u8L("Set position and orientation per glyph."), m_gui_cfg->max_tooltip_width);
            if (!m_text_lines.is_init())
                reinit_text_lines();
        }
    } else if (!per_glyph && m_text_lines.is_init())
        m_text_lines.reset();
    m_imgui->disabled_end(); // !can_use_per_glyph
        
    auto draw_align = [&align = font_prop.align, input_offset = m_gui_cfg->advanced_input_offset, &icons = m_icons, &m_imgui = m_imgui, &m_gui_cfg = m_gui_cfg]() {
        bool is_change = false;
        ImGui::SameLine(input_offset);
        if (align.first==FontProp::HorizontalAlign::left) draw(get_icon(icons, IconType::align_horizontal_left, IconState::hovered));
        else if (draw_button(icons, IconType::align_horizontal_left)) { align.first=FontProp::HorizontalAlign::left; is_change = true; }
        else if (ImGui::IsItemHovered()) m_imgui->tooltip(_u8L_CONTEXT(L_CONTEXT("Left", "Alignment"), "Alignment"), m_gui_cfg->max_tooltip_width);
        ImGui::SameLine();
        if (align.first==FontProp::HorizontalAlign::center) draw(get_icon(icons, IconType::align_horizontal_center, IconState::hovered));
        else if (draw_button(icons, IconType::align_horizontal_center)) { align.first=FontProp::HorizontalAlign::center; is_change = true; }
        else if (ImGui::IsItemHovered()) m_imgui->tooltip(_u8L_CONTEXT(L_CONTEXT("Center", "Alignment"), "Alignment"), m_gui_cfg->max_tooltip_width);
        ImGui::SameLine();
        if (align.first==FontProp::HorizontalAlign::right) draw(get_icon(icons, IconType::align_horizontal_right, IconState::hovered));
        else if (draw_button(icons, IconType::align_horizontal_right)) { align.first=FontProp::HorizontalAlign::right; is_change = true; }
        else if (ImGui::IsItemHovered()) m_imgui->tooltip(_u8L_CONTEXT(L_CONTEXT("Right", "Alignment"), "Alignment"), m_gui_cfg->max_tooltip_width);
 
        ImGui::SameLine(0, ImGui::GetStyle().ItemSpacing.x * 2.f); // ORCA use wider spacing for separation between horizontal / vertical alignment
 
        if (align.second==FontProp::VerticalAlign::top) draw(get_icon(icons, IconType::align_vertical_top, IconState::hovered));
        else if (draw_button(icons, IconType::align_vertical_top)) { align.second=FontProp::VerticalAlign::top; is_change = true; }
        else if (ImGui::IsItemHovered()) m_imgui->tooltip(_u8L_CONTEXT(L_CONTEXT("Top", "Alignment"), "Alignment"), m_gui_cfg->max_tooltip_width);
        ImGui::SameLine();
        if (align.second==FontProp::VerticalAlign::center) draw(get_icon(icons, IconType::align_vertical_center, IconState::hovered));
        else if (draw_button(icons, IconType::align_vertical_center)) { align.second=FontProp::VerticalAlign::center; is_change = true; }
        else if (ImGui::IsItemHovered()) m_imgui->tooltip(_u8L_CONTEXT(L_CONTEXT("Middle", "Alignment"), "Alignment"), m_gui_cfg->max_tooltip_width);
        ImGui::SameLine();
        if (align.second==FontProp::VerticalAlign::bottom) draw(get_icon(icons, IconType::align_vertical_bottom, IconState::hovered));
        else if (draw_button(icons, IconType::align_vertical_bottom)) { align.second=FontProp::VerticalAlign::bottom; is_change = true; }
        else if (ImGui::IsItemHovered()) m_imgui->tooltip(_u8L_CONTEXT(L_CONTEXT("Bottom", "Alignment"), "Alignment"), m_gui_cfg->max_tooltip_width);
        return is_change;
    };
    const FontProp::Align * def_align = stored_style ? &stored_style->prop.align : nullptr;
    if (revertible(tr.alignment, font_prop.align, def_align, _u8L("Revert alignment."), 0.0f, draw_align)) {
        if (font_prop.per_glyph)
            reinit_text_lines(m_text_lines.get_lines().size());
        // TODO: move with text in finalize to not change position
        process();
    }
    
    // TRN EmbossGizmo: font units
    std::string units = _u8L("points");
    std::string units_fmt = "%.0f " + units;
    
    // input gap between characters
    auto def_char_gap = stored_style ?
        &stored_style->prop.char_gap : nullptr;
 
    bool exist_change = false;
    int half_ascent = font_info.ascent / 2;
    int min_char_gap = -half_ascent;
    int max_char_gap = half_ascent;
    FontProp &current_prop = current_style.prop;
    if (rev_slider(tr.char_gap, current_prop.char_gap, def_char_gap, _u8L("Revert gap between characters"), 
        min_char_gap, max_char_gap, units_fmt, _L("Distance between characters"))){
        // Condition prevent recalculation when insertint out of limits value by imgui input
        const std::optional<int> &volume_char_gap = m_volume->text_configuration->style.prop.char_gap;
        if (!apply(current_prop.char_gap, limits.char_gap) ||
            !volume_char_gap.has_value() || volume_char_gap != current_prop.char_gap) {
            // char gap is stored inside of imgui font atlas
            m_style_manager.clear_imgui_font();
            exist_change = true;
        }
    }
    bool last_change = false;
    if (m_imgui->get_last_slider_status().deactivated_after_edit)
        last_change = true;
 
    // input gap between lines
    bool is_multiline = get_count_lines(m_volume->text_configuration->text) > 1; // TODO: cache count lines
    m_imgui->disabled_begin(!is_multiline);
    auto def_line_gap = stored_style ?
        &stored_style->prop.line_gap : nullptr;
    int min_line_gap = -half_ascent;
    int max_line_gap = half_ascent;
    if (rev_slider(tr.line_gap, current_prop.line_gap, def_line_gap, _u8L("Revert gap between lines"), 
        min_line_gap, max_line_gap, units_fmt, _L("Distance between lines"))){
        // Condition prevent recalculation when insertint out of limits value by imgui input
        const std::optional<int> &volume_line_gap = m_volume->text_configuration->style.prop.line_gap;
        if (!apply(current_prop.line_gap, limits.line_gap) ||
            !volume_line_gap.has_value() || volume_line_gap != current_prop.line_gap) {        
            // line gap is planed to be stored inside of imgui font atlas
            m_style_manager.clear_imgui_font();
            if (font_prop.per_glyph)
                reinit_text_lines(m_text_lines.get_lines().size());
            exist_change = true;
        }
    }
    if (m_imgui->get_last_slider_status().deactivated_after_edit)
        last_change = true;
    m_imgui->disabled_end(); // !is_multiline
 
    // input boldness
    auto def_boldness = stored_style ?
        &stored_style->prop.boldness : nullptr;
    int min_boldness = static_cast<int>(font_info.ascent * limits.boldness.gui.min);
    int max_boldness = static_cast<int>(font_info.ascent * limits.boldness.gui.max);
    if (rev_slider(tr.boldness, current_prop.boldness, def_boldness, _u8L("Undo boldness"), 
        min_boldness, max_boldness, units_fmt, _L("Tiny / Wide glyphs"))){
        const std::optional<float> &volume_boldness = m_volume->text_configuration->style.prop.boldness;
        if (!apply(current_prop.boldness, limits.boldness.values) ||
            !volume_boldness.has_value() || volume_boldness != current_prop.boldness)
            exist_change = true;
    }
    if (m_imgui->get_last_slider_status().deactivated_after_edit)
        last_change = true;
 
    // input italic
    auto def_skew = stored_style ?
        &stored_style->prop.skew : nullptr;
    if (rev_slider(tr.skew_ration, current_prop.skew, def_skew, _u8L("Undo letter's skew"),
        limits.skew.gui.min, limits.skew.gui.max, "%.2f", _L("Italic strength ratio"))){
        const std::optional<float> &volume_skew = m_volume->text_configuration->style.prop.skew;
        if (!apply(current_prop.skew, limits.skew.values) ||
            !volume_skew.has_value() ||volume_skew != current_prop.skew)
            exist_change = true;
    }
    if (m_imgui->get_last_slider_status().deactivated_after_edit)
        last_change = true;
    
    // input surface distance
    bool allowe_surface_distance = !use_surface && !m_volume->is_the_only_one_part();
    std::optional<float> &distance = current_style.distance;
    float prev_distance = distance.value_or(.0f);
    float min_distance = static_cast<float>(-2 * current_style.projection.depth);
    float max_distance = static_cast<float>(2 * current_style.projection.depth);
    auto def_distance = stored_style ?
        &stored_style->distance : nullptr;    
    m_imgui->disabled_begin(!allowe_surface_distance);    
    bool use_inch = wxGetApp().app_config->get_bool("use_inches");
    const std::string undo_move_tooltip = _u8L("Undo translation");
    const wxString move_tooltip = _L("Distance of the center of the text to the model surface.");
    bool is_moved = false;
    if (use_inch) {
        std::optional<float> distance_inch;
        if (distance.has_value()) distance_inch = (*distance * GizmoObjectManipulation::mm_to_in);
        std::optional<float> def_distance_inch;
        if (def_distance != nullptr) {
            if (def_distance->has_value()) def_distance_inch = GizmoObjectManipulation::mm_to_in * (*(*def_distance));
            def_distance = &def_distance_inch;
        }
        min_distance *= GizmoObjectManipulation::mm_to_in;
        max_distance *= GizmoObjectManipulation::mm_to_in;
        if (rev_slider(tr.from_surface, distance_inch, def_distance, undo_move_tooltip, min_distance, max_distance, "%.3f in", move_tooltip)) {
            if (distance_inch.has_value()) {
                distance = *distance_inch * GizmoObjectManipulation::in_to_mm;
            } else {
                distance.reset();
            }
            is_moved = true;
        }
    } else {
        if (rev_slider(tr.from_surface, distance, def_distance, undo_move_tooltip, 
        min_distance, max_distance, "%.2f mm", move_tooltip)) is_moved = true;
    }
 
    if (is_moved){
        if (font_prop.per_glyph){
            process(false);
        } else {
            do_local_z_move(m_parent.get_selection(), distance.value_or(.0f) - prev_distance);
        }
    }
 
    // Apply move to model(backend)
    if (m_imgui->get_last_slider_status().deactivated_after_edit) {
        m_parent.do_move(move_snapshot_name);
        if (font_prop.per_glyph)
            process();
    }
 
    m_imgui->disabled_end();  // allowe_surface_distance
 
    // slider for Clockwise angle in degress
    // stored angle is optional CCW and in radians
    // Convert stored value to degress
    // minus create clockwise roation from CCW
    float angle = current_style.angle.value_or(0.f);
    float angle_deg = static_cast<float>(-angle * 180 / M_PI);
    float def_angle_deg_val = 
        (!stored_style || !stored_style->angle.has_value()) ?
        0.f : (*stored_style->angle * -180 / M_PI);
    float* def_angle_deg = stored_style ?
        &def_angle_deg_val : nullptr;
    if (rev_slider(tr.rotation, angle_deg, def_angle_deg, _u8L("Undo rotation"), 
        limits.angle.min, limits.angle.max, u8"%.2f °",
                   _L("Rotate text Clockwise."))) {
        // convert back to radians and CCW
        double angle_rad = -angle_deg * M_PI / 180.0;
        Geometry::to_range_pi_pi(angle_rad);                
 
        double diff_angle = angle_rad - angle;
        do_local_z_rotate(m_parent.get_selection(), diff_angle);
        
        // calc angle after rotation
        const Selection &selection = m_parent.get_selection();
        const GLVolume *gl_volume = get_selected_gl_volume(selection);
        assert(gl_volume != nullptr);
        assert(m_style_manager.is_active_font());
        if (m_style_manager.is_active_font() && gl_volume != nullptr) 
            m_style_manager.get_style().angle = calc_angle(selection);
        
        if (font_prop.per_glyph)
            reinit_text_lines(m_text_lines.get_lines().size());
 
        // recalculate for surface cut
        if (use_surface || font_prop.per_glyph) 
            process(false);
    }
 
    // Apply rotation on model (backend)
    if (m_imgui->get_last_slider_status().deactivated_after_edit) {
        m_parent.do_rotate(rotation_snapshot_name);
 
        // recalculate for surface cut
        if (use_surface || font_prop.per_glyph)
            process();
    }
 
    // Keep up - lock button icon
    if (!m_volume->is_the_only_one_part()) {
        ImGui::SameLine(m_gui_cfg->lock_offset);
        const IconManager::Icon &icon = get_icon(m_icons, m_keep_up ? IconType::lock : IconType::unlock, IconState::activable);
        const IconManager::Icon &icon_hover = get_icon(m_icons, m_keep_up ? IconType::lock_bold : IconType::unlock_bold, IconState::activable);
        const IconManager::Icon &icon_disable = get_icon(m_icons, m_keep_up ? IconType::lock : IconType::unlock, IconState::disabled);
        if (button(icon, icon_hover, icon_disable))
            m_keep_up = !m_keep_up;
    
        if (ImGui::IsItemHovered())
            m_imgui->tooltip(m_keep_up?
                _u8L("Unlock the text's rotation when moving text along the object's surface."):
                _u8L("Lock the text's rotation when moving text along the object's surface.")
            , m_gui_cfg->max_tooltip_width);
    }
 
    // when more collection add selector
    if (ff.font_file->infos.size() > 1) {
        ImGui::AlignTextToFramePadding();
        ImGui::Text("%s", tr.collection.c_str());
        ImGui::SameLine(m_gui_cfg->advanced_input_offset);
        ImGui::SetNextItemWidth(m_gui_cfg->input_width);
        unsigned int selected = current_prop.collection_number.value_or(0);
        std::string tooltip = "";
        ImGuiWrapper::push_combo_style(m_parent.get_scale());
        if (ImGui::BBLBeginCombo("## Font collection", std::to_string(selected).c_str())) {
            for (unsigned int i = 0; i < ff.font_file->infos.size(); ++i) {
                ImGui::PushID(1 << (10 + i));
                bool is_selected = (i == selected);
                if (ImGui::BBLSelectable(std::to_string(i).c_str(), is_selected)) {
                    if (i == 0) current_prop.collection_number.reset();
                    else current_prop.collection_number = i;
                    exist_change = true;
                    last_change = true;
                }
                ImGui::PopID();
            }
            ImGui::EndCombo();
        } else if (ImGui::IsItemHovered()) {
            tooltip = _u8L("Select from True Type Collection.");
        }
        ImGuiWrapper::pop_combo_style();
        if (!tooltip.empty())
            m_imgui->tooltip(tooltip, m_gui_cfg->max_tooltip_width);
    }
 
    if (exist_change || last_change) {
        m_style_manager.clear_glyphs_cache();
        if (font_prop.per_glyph)
            reinit_text_lines();
        else
            m_text_lines.reset();
        process(last_change);
    }
 
    if (ImGui::Button(_u8L("Set text to face camera").c_str())) {
        assert(get_selected_volume(m_parent.get_selection()) == m_volume);
        const Camera &cam = wxGetApp().plater()->get_camera();
        auto wanted_up_limit = m_keep_up ? std::optional<double>(UP_LIMIT) : std::optional<double>{};
        if (face_selected_volume_to_camera(cam, m_parent, wanted_up_limit))
            volume_transformation_changed();
    } else if (ImGui::IsItemHovered()) {
        m_imgui->tooltip(_u8L("Orient the text towards the camera."), m_gui_cfg->max_tooltip_width);
    }
 
    //ImGui::SameLine(); if (ImGui::Button("Re-emboss")) GLGizmoEmboss::re_emboss(*m_volume);    
 
#ifdef ALLOW_DEBUG_MODE
    ImGui::Text("family = %s", (current_prop.family.has_value() ?
                                    current_prop.family->c_str() :
                                    " --- "));
    ImGui::Text("face name = %s", (current_prop.face_name.has_value() ?
                                       current_prop.face_name->c_str() :
                                       " --- "));
    ImGui::Text("style = %s",
                (current_prop.style.has_value() ? current_prop.style->c_str() :
                                                 " --- "));
    ImGui::Text("weight = %s", (current_prop.weight.has_value() ?
                                    current_prop.weight->c_str() :
                                    " --- "));
 
    std::string descriptor = style.path;
    ImGui::Text("descriptor = %s", descriptor.c_str());
#endif // ALLOW_DEBUG_MODE
}

Referenced by draw_window().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ draw_bold_button()

bool GLGizmoEmboss::draw_bold_button ( )

private

                                     {
    const wxFont &wx_font = m_style_manager.get_wx_font();
    const auto& ff = m_style_manager.get_font_file_with_cache();
    if (!wx_font.IsOk() || !ff.has_value()) {
        draw(get_icon(m_icons, IconType::bold, IconState::disabled));
        return false;
    }
    
    std::optional<float> &boldness = m_style_manager.get_font_prop().boldness;
    bool is_font_bold = boldness.has_value() || WxFontUtils::is_bold(wx_font);
    if (is_font_bold) {
        // unset bold
        if (clickable(get_icon(m_icons, IconType::bold, IconState::hovered),
                      get_icon(m_icons, IconType::unbold, IconState::hovered))) {
            boldness.reset();
            if (wx_font.GetWeight() != wxFontWeight::wxFONTWEIGHT_NORMAL) {
                wxFont new_wx_font = wx_font; // copy
                new_wx_font.SetWeight(wxFontWeight::wxFONTWEIGHT_NORMAL);
                if(!m_style_manager.set_wx_font(new_wx_font))
                    return false;
            }
            return true;
        }
        if (ImGui::IsItemHovered())
            m_imgui->tooltip(_u8L("Unset bold"), m_gui_cfg->max_tooltip_width);
    } else {
        // set bold
        if (draw_button(m_icons, IconType::bold)) {
            wxFont new_wx_font = wx_font; // copy
            auto new_ff = WxFontUtils::set_bold(new_wx_font, *ff.font_file);
            if (new_ff != nullptr) {
                if(!m_style_manager.set_wx_font(new_wx_font, std::move(new_ff)))
                    return false;
            } else {
                // bold font can't be loaded
                // set up boldness
                boldness = 20.f;
                //font_file->cache.empty();
            }
            return true;
        }
        if (ImGui::IsItemHovered())
            m_imgui->tooltip(_u8L("Set bold"), m_gui_cfg->max_tooltip_width);
    }
    return false;
}

References _u8L, anonymous_namespace{GLGizmoEmboss.cpp}::bold, Slic3r::GUI::clickable(), anonymous_namespace{GLGizmoEmboss.cpp}::disabled, Slic3r::GUI::draw(), anonymous_namespace{GLGizmoEmboss.cpp}::hovered, Slic3r::GUI::WxFontUtils::is_bold(), m_gui_cfg, m_icons, Slic3r::GUI::GLGizmoBase::m_imgui, m_style_manager, Slic3r::GUI::WxFontUtils::set_bold(), and anonymous_namespace{GLGizmoEmboss.cpp}::unbold.

Referenced by draw_font_list_line().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ draw_delete_style_button()

void GLGizmoEmboss::draw_delete_style_button ( )

private

                                             {
    bool is_stored  = m_style_manager.exist_stored_style();
    bool is_last    = m_style_manager.get_styles().size() == 1;
    bool can_delete = is_stored && !is_last;
 
    if (draw_button(m_icons, IconType::erase, !can_delete)) {
        std::string style_name = m_style_manager.get_style().name; // copy
        wxString dialog_title = _L("Remove style");
        size_t next_style_index = std::numeric_limits<size_t>::max();
        Plater *plater = wxGetApp().plater();
        bool exist_change = false;
        while (true) {
            // NOTE: can't use previous loaded activ index -> erase could change index
            size_t active_index = m_style_manager.get_style_index();
            next_style_index = (active_index > 0) ? active_index - 1 :
                                                   active_index + 1;
            
            if (next_style_index >= m_style_manager.get_styles().size()) {
                MessageDialog msg(plater, _L("Can't remove the last existing style."), dialog_title, wxICON_ERROR | wxOK);
                msg.ShowModal();
                break;
            }
 
            // IMPROVE: add function can_load?
            // clean unactivable styles
            if (!m_style_manager.load_style(next_style_index)) {
                m_style_manager.erase(next_style_index);
                exist_change = true;
                continue;
            }
 
            wxString message = GUI::format_wxstr(_L("Are you sure you want to permanently remove the \"%1%\" style?"), style_name);
            MessageDialog msg(plater, message, dialog_title, wxICON_WARNING | wxYES | wxNO);
            if (msg.ShowModal() == wxID_YES) {
                // delete style
                m_style_manager.erase(active_index);
                exist_change = true;
                process();
            } else {
                // load back style
                m_style_manager.load_style(active_index);
            }
            break;
        }
        if (exist_change)
            m_style_manager.store_styles_to_app_config(wxGetApp().app_config);
    }
 
    if (ImGui::IsItemHovered()) {
        const std::string &style_name = m_style_manager.get_style().name;
        std::string tooltip;
        if (can_delete)        tooltip = GUI::format(_L("Delete \"%1%\" style."), style_name);
        else if (is_last)      tooltip = GUI::format(_L("Can't delete \"%1%\". It is last style."), style_name);
        else/*if(!is_stored)*/ tooltip = GUI::format(_L("Can't delete temporary style \"%1%\"."), style_name);      
        m_imgui->tooltip(tooltip, m_gui_cfg->max_tooltip_width);  
    }
}

References _L, anonymous_namespace{GLGizmoEmboss.cpp}::erase, exist_change(), Slic3r::GUI::format(), Slic3r::GUI::format_wxstr(), m_gui_cfg, m_icons, Slic3r::GUI::GLGizmoBase::m_imgui, m_style_manager, Slic3r::GUI::plater(), process(), and Slic3r::GUI::DPIAware< P >::ShowModal().

Referenced by draw_style_list().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ draw_depth()

void GLGizmoEmboss::draw_depth ( bool use_inch )

private

{
    double &value = m_style_manager.get_style().projection.depth;
    const StyleManager::Style * stored_style = m_style_manager.get_stored_style();
    const double *stored = ((stored_style!=nullptr)? &stored_style->projection.depth : nullptr);
    const std::string  revert_emboss_depth = _u8L("Revert embossed depth.");
    const char *size_format = ((use_inch) ? "%.3f in" : "%.2f mm");
    const std::string  name = m_gui_cfg->translations.depth;
    if (rev_input_mm(name, value, stored, revert_emboss_depth, 0.1, 1., size_format, use_inch, m_scale_depth)){
        // size can't be zero or negative
        apply(value, limits.emboss);
 
        // only different value need process
        if(!is_approx(value, m_volume->emboss_shape->projection.depth))
            process();
    }
}

References _u8L, Slic3r::apply(), Slic3r::EmbossProjection::depth, Slic3r::is_approx(), m_gui_cfg, m_scale_depth, m_style_manager, m_volume, process(), Slic3r::GUI::Emboss::StyleManager::Style::projection, and rev_input_mm().

Referenced by draw_window().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ draw_font_list()

void GLGizmoEmboss::draw_font_list ( )

private

{
    ImGuiWrapper::push_combo_style(m_gui_cfg->screen_scale);
    ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0.0f, 0.0f));
    ImGui::PushStyleVar(ImGuiStyleVar_PopupRounding, 4.0f * m_gui_cfg->screen_scale);
 
    wxString tooltip_name = "";
 
    // Set partial
    wxString actual_face_name;
    if (m_style_manager.is_active_font()) {
        const wxFont &wx_font = m_style_manager.get_wx_font();
        if (wx_font.IsOk())
            actual_face_name = wx_font.GetFaceName();
    }
    // name of actual selected font
    const char * selected = (!actual_face_name.empty()) ?
        (const char *)actual_face_name.c_str() : " --- ";
 
    // Do not remove font face during enumeration
    // When deletation of font appear this variable is set
    std::optional<size_t> del_index;
    
    ImGui::SetNextItemWidth(2 * m_gui_cfg->input_width);
    std::vector<int> filtered_items_idx;
    bool             is_filtered = false;
    if (m_imgui->bbl_combo_with_filter("##Combo_Font", selected, m_face_names->faces_names,
        &filtered_items_idx, &is_filtered, m_imgui->scaled(32.f / 15.f))) {
        bool set_selection_focus = false;
        if (!m_face_names->is_init) {
            init_face_names(*m_face_names);
            set_selection_focus = true;
        }
 
        if (!m_face_names->has_truncated_names)
            init_truncated_names(*m_face_names, m_gui_cfg->input_width);
 
        if (m_face_names->texture_id == 0)
            init_font_name_texture();
 
        int show_items_count = is_filtered ? filtered_items_idx.size() : m_face_names->faces.size();
 
        ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(0, 0));
        ImGui::PushStyleVar(ImGuiStyleVar_ItemInnerSpacing, ImVec2(0, 0));
        ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, 0);
        ImGui::PushStyleVar(ImGuiStyleVar_SelectableTextAlign, ImVec2(0.0f, 0.5f)); // vertically align label
 
        for (int i = 0; i < show_items_count; i++) {
            int idx = is_filtered ? filtered_items_idx[i] : i;
            FaceName &face = m_face_names->faces[idx];
            const wxString &wx_face_name = face.wx_name;
 
            ImGui::PushID(idx);
            ScopeGuard sg([]() { ImGui::PopID(); });
            bool is_selected = (actual_face_name == wx_face_name);
            ImVec2 selectable_size(0, m_imgui->scaled(32.f / 15.f));
            ImGuiSelectableFlags flags = 0;
            if (ImGui::BBLSelectable(face.name_truncated.c_str(), is_selected, flags, selectable_size)) {
                if (!select_facename(wx_face_name)) {
                    del_index = idx;
                    MessageDialog(wxGetApp().plater(), GUI::format_wxstr(_L("Font \"%1%\" can't be selected."), wx_face_name));
                } else {
                    ImGui::CloseCurrentPopup();
                }
            }
            // tooltip as full name of font face
            if (ImGui::IsItemHovered())
                tooltip_name = wx_face_name;
 
            if (is_selected) {
                ImGui::SetItemDefaultFocus();
            }
 
            // on first draw set focus on selected font
            if (set_selection_focus && is_selected)
                ImGui::SetScrollHereY();
            ::draw_font_preview(face, m_text, *m_face_names, *m_gui_cfg, ImGui::IsItemVisible());
        }
        
        ImGui::PopStyleVar(4); // ImGuiStyleVar_ItemSpacing, ImGuiStyleVar_ItemInnerSpacing, ImGuiStyleVar_FrameRounding, ImGuiStyleVar_SelectableTextAlign
        ImGui::EndListBox();
        ImGui::EndPopup();
    } else if (m_face_names->is_init) {
        // Just one after close combo box
        // free texture and set id to zero
        m_face_names->is_init = false;
        // cancel all process for generation of texture
        for (FaceName &face : m_face_names->faces)
            if (face.cancel != nullptr)
                face.cancel->store(true);
        glsafe(::glDeleteTextures(1, &m_face_names->texture_id));
        m_face_names->texture_id = 0;
    }
 
    // delete unloadable face name when try to use
    if (del_index.has_value()) {
        auto face = m_face_names->faces.begin() + (*del_index);
        std::vector<wxString>& bad = m_face_names->bad;
        // sorted insert into bad fonts
        auto it = std::upper_bound(bad.begin(), bad.end(), face->wx_name);
        bad.insert(it, face->wx_name);
        m_face_names->faces.erase(face);
        m_face_names->faces_names.erase(m_face_names->faces_names.begin() + (*del_index));
        // update cached file
        store(*m_face_names);
    }
 
#ifdef ALLOW_ADD_FONT_BY_FILE
    ImGui::SameLine();
    // select font file by file browser
    if (draw_button(IconType::open_file)) {
        if (choose_true_type_file()) { 
            process();
        }
    } else if (ImGui::IsItemHovered())
        ImGui::SetTooltip("Add file with font(.ttf, .ttc)");
#endif //  ALLOW_ADD_FONT_BY_FILE
 
#ifdef ALLOW_ADD_FONT_BY_OS_SELECTOR
    ImGui::SameLine();
    if (draw_button(IconType::system_selector)) {
        if (choose_font_by_wxdialog()) {
            process();
        }
    } else if (ImGui::IsItemHovered())
        ImGui::SetTooltip("Open dialog for choose from fonts.");
#endif //  ALLOW_ADD_FONT_BY_OS_SELECTOR
    
    ImGui::PopStyleVar(2);
    ImGuiWrapper::pop_combo_style();
 
    if (!tooltip_name.IsEmpty())
        m_imgui->tooltip(tooltip_name, m_gui_cfg->max_tooltip_width);
}

References _L, Slic3r::GUI::format_wxstr(), glDeleteTextures, glsafe, init_font_name_texture(), m_face_names, m_gui_cfg, Slic3r::GUI::GLGizmoBase::m_imgui, m_style_manager, m_text, anonymous_namespace{GLGizmoEmboss.cpp}::open_file, Slic3r::GUI::plater(), Slic3r::GUI::ImGuiWrapper::pop_combo_style(), process(), Slic3r::GUI::ImGuiWrapper::push_combo_style(), select_facename(), and anonymous_namespace{GLGizmoEmboss.cpp}::system_selector.

Referenced by draw_font_list_line().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ draw_font_list_line()

void GLGizmoEmboss::draw_font_list_line ( )

private

{
    ImGui::AlignTextToFramePadding();
 
    bool exist_stored_style   = m_style_manager.exist_stored_style();
    bool exist_change_in_font = m_style_manager.is_font_changed();
    const std::string& font_text = m_gui_cfg->translations.font;
    if (exist_change_in_font || !exist_stored_style)
        ImGuiWrapper::text_colored(ImGuiWrapper::COL_MODIFIED, font_text); // ORCA match color
    else
        ImGuiWrapper::text(font_text);
 
    ImGui::SameLine(m_gui_cfg->input_offset);
 
    draw_font_list();
 
    bool exist_change = false;
    if (!m_is_unknown_font) {
        ImGui::SameLine();
        if (draw_italic_button())
            exist_change = true;
        ImGui::SameLine();
        if (draw_bold_button())
            exist_change = true;
    } else {
        // when exist unknown font add confirmation button
        ImGui::SameLine();
        // Apply for actual selected font
        if (ImGui::Button(_u8L("Apply").c_str()))
            exist_change = true;
    }
 
    EmbossStyle &style = m_style_manager.get_style();
    auto r_icon = get_icon(m_icons, IconType::undo, IconState::hovered);
    if (exist_change_in_font == false) {
        ImGui::PushStyleVar(ImGuiStyleVar_Alpha, 0.0f);
        m_imgui->disabled_begin(true);
    }
 
    ImGui::SameLine();
    if (Slic3r::GUI::button(r_icon, r_icon, r_icon)) { // ORCA draw bottom with same orange color
        const EmbossStyle *stored_style = m_style_manager.get_stored_style();
 
        style.path          = stored_style->path;
        style.prop.boldness = stored_style->prop.boldness;
        style.prop.skew     = stored_style->prop.skew;
 
        wxFont new_wx_font = WxFontUtils::load_wxFont(style.path);
        if (new_wx_font.IsOk() && m_style_manager.set_wx_font(new_wx_font))
            exist_change = true;
        } else if (ImGui::IsItemHovered())
        m_imgui->tooltip(_u8L("Revert font changes."), m_gui_cfg->max_tooltip_width);
 
    if (exist_change_in_font == false) {
        ImGui::PopStyleVar();
        m_imgui->disabled_end();
    }
 
    if (exist_change) {
        m_style_manager.clear_glyphs_cache();
        if (m_style_manager.get_font_prop().per_glyph)
            reinit_text_lines(m_text_lines.get_lines().size());
        process();
    }
}

References _u8L, Slic3r::FontProp::boldness, Slic3r::GUI::button(), Slic3r::GUI::ImGuiWrapper::COL_MODIFIED, draw_bold_button(), draw_font_list(), draw_italic_button(), exist_change(), anonymous_namespace{GLGizmoEmboss.cpp}::hovered, Slic3r::GUI::WxFontUtils::load_wxFont(), m_gui_cfg, m_icons, Slic3r::GUI::GLGizmoBase::m_imgui, m_is_unknown_font, m_style_manager, m_text_lines, Slic3r::EmbossStyle::path, process(), Slic3r::EmbossStyle::prop, reinit_text_lines(), Slic3r::FontProp::skew, style, Slic3r::GUI::ImGuiWrapper::text(), Slic3r::GUI::ImGuiWrapper::text_colored(), and anonymous_namespace{GLGizmoEmboss.cpp}::undo.

Referenced by draw_window().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ draw_height()

void GLGizmoEmboss::draw_height ( bool use_inch )

private

{
    float &value = m_style_manager.get_font_prop().size_in_mm;
    const EmbossStyle* stored_style = m_style_manager.get_stored_style();
    const float *stored = (stored_style != nullptr)? &stored_style->prop.size_in_mm : nullptr;
    const char *size_format = use_inch ? "%.2f in" : "%.1f mm";
    const std::string revert_text_size = _u8L("Revert text size.");
    const std::string& name = m_gui_cfg->translations.height;
    if (rev_input_mm(name, value, stored, revert_text_size, 0.1f, 1.f, size_format, use_inch, m_scale_height))
        if (set_height())
            process();
}

References _u8L, m_gui_cfg, m_scale_height, m_style_manager, process(), Slic3r::EmbossStyle::prop, rev_input_mm(), set_height(), and Slic3r::FontProp::size_in_mm.

Referenced by draw_window().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ draw_italic_button()

bool GLGizmoEmboss::draw_italic_button ( )

private

{
    const wxFont &wx_font = m_style_manager.get_wx_font(); 
    const auto& ff = m_style_manager.get_font_file_with_cache();
    if (!wx_font.IsOk() || !ff.has_value()) { 
        draw(get_icon(m_icons, IconType::italic, IconState::disabled));
        return false;
    }
 
    std::optional<float> &skew = m_style_manager.get_font_prop().skew;
    bool is_font_italic = skew.has_value() || WxFontUtils::is_italic(wx_font);
    if (is_font_italic) {
        // unset italic
        if (clickable(get_icon(m_icons, IconType::italic, IconState::hovered),
                      get_icon(m_icons, IconType::unitalic, IconState::hovered))) {
            skew.reset();
            if (wx_font.GetStyle() != wxFontStyle::wxFONTSTYLE_NORMAL) {
                wxFont new_wx_font = wx_font; // copy
                new_wx_font.SetStyle(wxFontStyle::wxFONTSTYLE_NORMAL);
                if(!m_style_manager.set_wx_font(new_wx_font))
                    return false;
            }
            return true;
        }
        if (ImGui::IsItemHovered())
            m_imgui->tooltip(_u8L("Unset italic"), m_gui_cfg->max_tooltip_width);
    } else {
        // set italic
        if (draw_button(m_icons, IconType::italic)) {
            wxFont new_wx_font = wx_font; // copy
            auto new_ff = WxFontUtils::set_italic(new_wx_font, *ff.font_file);
            if (new_ff != nullptr) {
                if(!m_style_manager.set_wx_font(new_wx_font, std::move(new_ff)))
                    return false;
            } else {
                // italic font doesn't exist 
                // add skew when wxFont can't set it
                skew = 0.2f;
            }            
            return true;
        }
        if (ImGui::IsItemHovered())
            m_imgui->tooltip(_u8L("Set italic"), m_gui_cfg->max_tooltip_width);
    }
    return false;
}

References _u8L, Slic3r::GUI::clickable(), anonymous_namespace{GLGizmoEmboss.cpp}::disabled, Slic3r::GUI::draw(), anonymous_namespace{GLGizmoEmboss.cpp}::hovered, Slic3r::GUI::WxFontUtils::is_italic(), anonymous_namespace{GLGizmoEmboss.cpp}::italic, m_gui_cfg, m_icons, Slic3r::GUI::GLGizmoBase::m_imgui, m_style_manager, Slic3r::GUI::WxFontUtils::set_italic(), and anonymous_namespace{GLGizmoEmboss.cpp}::unitalic.

Referenced by draw_font_list_line().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ draw_model_type()

void GLGizmoEmboss::draw_model_type ( )

private

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

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

Referenced by draw_window().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ draw_style_add_button()

void GLGizmoEmboss::draw_style_add_button ( )

private

{
    bool only_add_style = !m_style_manager.exist_stored_style();
    bool can_add        = true;
    if (only_add_style &&
        m_volume->text_configuration->style.type != WxFontUtils::get_current_type())
        can_add = false;
 
    std::string title    = _u8L("Save as new style");
    const char *popup_id = title.c_str();
    // save as new style
    ImGui::SameLine();
    if (draw_button(m_icons, IconType::add, !can_add)) {
        if (!m_style_manager.exist_stored_style()) {
            m_style_manager.store_styles_to_app_config(wxGetApp().app_config);
        } else {
            ImGui::OpenPopup(popup_id);
        }
    } else if (ImGui::IsItemHovered()) {
        if (!can_add) {
            m_imgui->tooltip(_u8L("Only valid font can be added to style."), m_gui_cfg->max_tooltip_width);
        } else if (only_add_style) {
            m_imgui->tooltip(_u8L("Add style to my list."), m_gui_cfg->max_tooltip_width);
        } else {
            m_imgui->tooltip(_u8L("Save as new style."), m_gui_cfg->max_tooltip_width);
        }
    }
 
    if (ImGui::BeginPopupModal(popup_id, nullptr, ImGuiWindowFlags_AlwaysAutoResize)) {
        m_imgui->disable_background_fadeout_animation();
        draw_style_save_as_popup();
        ImGui::EndPopup();
    }
}

References _u8L, anonymous_namespace{GLGizmoEmboss.cpp}::add, draw_style_save_as_popup(), Slic3r::GUI::WxFontUtils::get_current_type(), m_gui_cfg, m_icons, Slic3r::GUI::GLGizmoBase::m_imgui, m_style_manager, and m_volume.

Referenced by draw_style_list().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ draw_style_list()

void GLGizmoEmboss::draw_style_list ( )

private

                                    {
    if (!m_style_manager.is_active_font()) return;
 
    const StyleManager::Style *stored_style = nullptr;
    bool is_stored = m_style_manager.exist_stored_style();
    if (is_stored)
        stored_style = m_style_manager.get_stored_style();
    const StyleManager::Style &current_style = m_style_manager.get_style();
    bool is_changed = (stored_style)? !(*stored_style == current_style) : true;    
    bool is_modified = is_stored && is_changed;
 
    const float &max_style_name_width = m_gui_cfg->max_style_name_width;
    std::string &trunc_name = m_style_manager.get_truncated_name();
    if (trunc_name.empty()) {
        // generate trunc name
        std::string current_name = current_style.name;
        ImGuiWrapper::escape_double_hash(current_name);
        trunc_name = ImGuiWrapper::trunc(current_name, max_style_name_width);
    }
 
    ImGui::AlignTextToFramePadding();
 
    std::string title = _u8L("Style");
    if (m_style_manager.exist_stored_style())
        ImGui::Text("%s", title.c_str());
    else
        ImGui::TextColored(ImGuiWrapper::COL_ORCA, "%s", title.c_str());
        
    ImGui::SameLine(m_gui_cfg->input_offset);
 
    ImGui::SetNextItemWidth(2 * m_gui_cfg->input_width);
    auto add_text_modify = [&is_modified](const std::string& name) {
        if (!is_modified) return name;
        return name + Preset::suffix_modified();
    };
    std::optional<size_t> selected_style_index;
    std::string tooltip = "";
    ImGuiWrapper::push_combo_style(m_parent.get_scale());
    if (ImGui::BBLBeginCombo("##style_selector", add_text_modify(trunc_name).c_str())) {
        m_style_manager.init_style_images(m_gui_cfg->max_style_image_size, m_text);
        m_style_manager.init_trunc_names(max_style_name_width);
        std::optional<std::pair<size_t,size_t>> swap_indexes;
 
        ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(0, 0));
        ImGui::PushStyleVar(ImGuiStyleVar_ItemInnerSpacing, ImVec2(0, 0));
        ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, 0);
        ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0, 0)); 
        ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(0, 0));
        ImGui::PushStyleVar(ImGuiStyleVar_SelectableTextAlign, ImVec2(0.0f, 0.5f)); // vertically align label
 
        const StyleManager::Styles &styles = m_style_manager.get_styles();
        for (const StyleManager::Style &style : styles) {
            size_t index = &style - &styles.front();
            const std::string &actual_style_name = style.name;
            ImGui::PushID(actual_style_name.c_str());
            bool is_selected = (index == m_style_manager.get_style_index());
 
            ImVec2 selectable_size(0, m_imgui->scaled(32.f / 15.f)); // 0.0f -> calculated during draw
            // allow click delete button
            ImGuiSelectableFlags_ flags = ImGuiSelectableFlags_AllowItemOverlap; 
            if (ImGui::BBLSelectable(style.truncated_name.c_str(), is_selected, flags, selectable_size)) {
                selected_style_index = index;
            } else if (ImGui::IsItemHovered())
                tooltip = actual_style_name;
 
            // reorder items
            if (ImGui::IsItemActive() && !ImGui::IsItemHovered()) {
                if (ImGui::GetMouseDragDelta(0).y < 0.f) {
                    if (index > 0) 
                        swap_indexes = {index, index - 1};
                } else if ((index + 1) < styles.size())
                    swap_indexes = {index, index + 1};
                if (swap_indexes.has_value()) 
                    ImGui::ResetMouseDragDelta();
            }
 
            const std::optional<StyleManager::StyleImage> &img = style.image;            
            // draw style name
            if (img.has_value()) {
                ImGui::SameLine(max_style_name_width);
                ImVec4 tint_color = ImGui::GetStyleColorVec4(ImGuiCol_Text);
                ImGui::Image(img->texture_id, img->tex_size, img->uv0, img->uv1, tint_color);
            }
 
            ImGui::PopID();
        }
        if (swap_indexes.has_value()) 
            m_style_manager.swap(swap_indexes->first,
                                swap_indexes->second);
 
        // ImGuiStyleVar_ItemSpacing, ImGuiStyleVar_ItemInnerSpacing, ImGuiStyleVar_FrameRounding, 
        // ImGuiStyleVar_WindowPadding, ImGuiStyleVar_FramePadding, ImGuiStyleVar_SelectableTextAlign
        ImGui::PopStyleVar(6); 
        ImGui::EndCombo();
    } else {
        // do not keep in memory style images when no combo box open
        m_style_manager.free_style_images();
        if (ImGui::IsItemHovered()) {            
            std::string style_name = add_text_modify(current_style.name);
            tooltip = is_modified?
                GUI::format(_L("Modified style \"%1%\""), current_style.name):
                GUI::format(_L("Current style is \"%1%\""), current_style.name);
        }
    }
    ImGuiWrapper::pop_combo_style();
    if (!tooltip.empty())
        m_imgui->tooltip(tooltip, m_gui_cfg->max_tooltip_width);
        
    // Check whether user wants lose actual style modification
    if (selected_style_index.has_value() && is_modified) { 
        const std::string & style_name = m_style_manager.get_styles()[*selected_style_index].name;        
        wxString message = GUI::format_wxstr(_L("Changing style to \"%1%\" will discard current style modification.\n\nWould you like to continue anyway?"), style_name);
        MessageDialog not_loaded_style_message(nullptr, message, _L("Warning"), wxICON_WARNING | wxYES | wxNO);
        if (not_loaded_style_message.ShowModal() != wxID_YES) 
            selected_style_index.reset();
    }
 
    // selected style from combo box
    if (selected_style_index.has_value()) {
        const StyleManager::Style &style = m_style_manager.get_styles()[*selected_style_index];
        // create copy to be able do fix transformation only when successfully load style
        StyleManager::Style cur_s = current_style;  // copy
        StyleManager::Style new_s = style;    // copy
        if (m_style_manager.load_style(*selected_style_index)) {
            ::fix_transformation(cur_s, new_s, m_parent);
            process();
        } else {
            wxString title   = _L("Not valid style.");
            wxString message = GUI::format_wxstr(_L("Style \"%1%\" can't be used and will be removed from a list."), style.name);
            MessageDialog not_loaded_style_message(nullptr, message, title, wxOK);
            not_loaded_style_message.ShowModal();
            m_style_manager.erase(*selected_style_index);
        }
    }
 
    ImGui::SameLine();
    draw_style_rename_button();
        
    ImGui::SameLine();
    draw_style_save_button(is_modified);
 
    ImGui::SameLine();
    draw_style_add_button();
 
    // delete button
    ImGui::SameLine();
    draw_delete_style_button();
}

References _L, _u8L, Slic3r::GUI::ImGuiWrapper::COL_ORCA, draw_delete_style_button(), draw_style_add_button(), draw_style_rename_button(), draw_style_save_button(), Slic3r::GUI::ImGuiWrapper::escape_double_hash(), Slic3r::GUI::format(), Slic3r::GUI::format_wxstr(), m_gui_cfg, Slic3r::GUI::GLGizmoBase::m_imgui, Slic3r::GUI::GLGizmoBase::m_parent, m_style_manager, m_text, Slic3r::EmbossStyle::name, Slic3r::GUI::ImGuiWrapper::pop_combo_style(), process(), Slic3r::GUI::ImGuiWrapper::push_combo_style(), Slic3r::GUI::DPIAware< P >::ShowModal(), style, Slic3r::Preset::suffix_modified(), and Slic3r::GUI::ImGuiWrapper::trunc().

Referenced by draw_window().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ draw_style_rename_button()

void GLGizmoEmboss::draw_style_rename_button ( )

private

{
    bool can_rename = m_style_manager.exist_stored_style();
    std::string title = _u8L("Rename style");
    const char * popup_id = title.c_str();
    if (draw_button(m_icons, IconType::rename, !can_rename)) {
        assert(m_style_manager.get_stored_style());
        ImGui::OpenPopup(popup_id);
    }
    else if (ImGui::IsItemHovered()) {
        if (can_rename) m_imgui->tooltip(_u8L("Rename current style."), m_gui_cfg->max_tooltip_width);
        else            m_imgui->tooltip(_u8L("Can't rename temporary style."), m_gui_cfg->max_tooltip_width);
    }
    if (ImGui::BeginPopupModal(popup_id, 0, ImGuiWindowFlags_AlwaysAutoResize)) {
        m_imgui->disable_background_fadeout_animation();
        draw_style_rename_popup();
        ImGui::EndPopup();
    }
}

References _u8L, draw_style_rename_popup(), m_gui_cfg, m_icons, Slic3r::GUI::GLGizmoBase::m_imgui, m_style_manager, and anonymous_namespace{GLGizmoEmboss.cpp}::rename.

Referenced by draw_style_list().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ draw_style_rename_popup()

void GLGizmoEmboss::draw_style_rename_popup ( )

private

                                            {
    std::string& new_name = m_style_manager.get_style().name;
    const std::string &old_name = m_style_manager.get_stored_style()->name;
    std::string text_in_popup = GUI::format(_L("Rename style (%1%) for embossing text"), old_name) + ": ";
    ImGui::Text("%s", text_in_popup.c_str());
        
    bool is_unique = (new_name == old_name) || // could be same as before rename
        m_style_manager.is_unique_style_name(new_name);
 
    bool allow_change = false;
    if (new_name.empty()) {
        ImGuiWrapper::text_colored(ImGuiWrapper::COL_ORANGE_DARK, _u8L("Name can't be empty."));
    }else if (!is_unique) { 
        ImGuiWrapper::text_colored(ImGuiWrapper::COL_ORANGE_DARK, _u8L("Name has to be unique."));
    } else {
        ImGui::NewLine();
        allow_change = true;
    }
 
    bool store = false;
    ImGuiInputTextFlags flags = ImGuiInputTextFlags_EnterReturnsTrue;
    if (ImGui::InputText("##rename style", &new_name, flags) && allow_change) store = true;
    if (m_imgui->button(_L("OK"), ImVec2(0.f, 0.f), allow_change)) store = true;
    ImGui::SameLine();
    if (ImGui::Button(_u8L("Cancel").c_str())) {
        new_name = old_name;
        ImGui::CloseCurrentPopup();
    }
 
    if (store) {
        // rename style in all objects and volumes
        for (const ModelObject *mo :wxGetApp().plater()->model().objects) {
            for (ModelVolume *mv : mo->volumes) { 
                if (!mv->text_configuration.has_value()) continue;
                std::string& name = mv->text_configuration->style.name;
                if (name != old_name) continue;
                name = new_name;
            }
        }
        
        m_style_manager.rename(new_name);
        m_style_manager.store_styles_to_app_config();
        ImGui::CloseCurrentPopup();
    }
}

References _L, _u8L, Slic3r::GUI::ImGuiWrapper::COL_ORANGE_DARK, Slic3r::GUI::format(), Slic3r::GUI::GLGizmoBase::m_imgui, m_style_manager, Slic3r::GUI::plater(), Slic3r::GUI::ImGuiWrapper::text_colored(), and Slic3r::ModelVolume::text_configuration.

Referenced by draw_style_rename_button().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ draw_style_save_as_popup()

void GLGizmoEmboss::draw_style_save_as_popup ( )

private

                                             {
    ImGui::Text("%s", (_u8L("New name of style") +": ").c_str());
 
    // use name inside of volume configuration as temporary new name
    std::string &new_name = m_volume->text_configuration->style.name;
    bool is_unique = m_style_manager.is_unique_style_name(new_name);        
    bool allow_change = false;
    if (new_name.empty()) {
        ImGuiWrapper::text_colored(ImGuiWrapper::COL_ORANGE_DARK, _u8L("Name can't be empty."));
    }else if (!is_unique) { 
        ImGuiWrapper::text_colored(ImGuiWrapper::COL_ORANGE_DARK, _u8L("Name has to be unique."));
    } else {
        ImGui::NewLine();
        allow_change = true;
    }
 
    bool save_style = false;
    ImGuiInputTextFlags flags = ImGuiInputTextFlags_EnterReturnsTrue;
    if (ImGui::InputText("##save as style", &new_name, flags))
        save_style = true;
        
    if (m_imgui->button(_L("OK"), ImVec2(0.f, 0.f), allow_change))
        save_style = true;
 
    ImGui::SameLine();
    if (ImGui::Button(_u8L("Cancel").c_str())){
        // write original name to volume TextConfiguration
        new_name = m_style_manager.get_style().name;
        ImGui::CloseCurrentPopup();
    }
 
    if (save_style && allow_change) {
        m_style_manager.add_style(new_name);
        m_style_manager.store_styles_to_app_config();
        ImGui::CloseCurrentPopup();
    }
}

References _L, _u8L, Slic3r::GUI::ImGuiWrapper::COL_ORANGE_DARK, Slic3r::GUI::GLGizmoBase::m_imgui, m_style_manager, m_volume, and Slic3r::GUI::ImGuiWrapper::text_colored().

Referenced by draw_style_add_button().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ draw_style_save_button()

void GLGizmoEmboss::draw_style_save_button ( bool is_modified )

private

{
    if (draw_button(m_icons, IconType::save, !is_modified)) {
        // save styles to app config
        m_style_manager.store_styles_to_app_config();
    }else if (ImGui::IsItemHovered()) {
        std::string tooltip;
        if (!m_style_manager.exist_stored_style()) {
            tooltip = _u8L("First Add style to list.");
        } else if (is_modified) {
            tooltip = GUI::format(_L("Save %1% style"), m_style_manager.get_style().name);
        } else {
            tooltip = _u8L("No changes to save.");
        }
        m_imgui->tooltip(tooltip, m_gui_cfg->max_tooltip_width);
    }
}

References _L, _u8L, Slic3r::GUI::format(), m_gui_cfg, m_icons, Slic3r::GUI::GLGizmoBase::m_imgui, m_style_manager, and anonymous_namespace{GLGizmoEmboss.cpp}::save.

Referenced by draw_style_list().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ draw_text_input()

void GLGizmoEmboss::draw_text_input ( )

private

{
    auto create_range_text_prep = [&mng = m_style_manager, &text = m_text, &exist_unknown = m_text_contain_unknown_glyph]() {
        auto& ff = mng.get_font_file_with_cache();
        assert(ff.has_value());
        const auto &cn = mng.get_font_prop().collection_number;
        unsigned int font_index = (cn.has_value()) ? *cn : 0;
        return create_range_text(text, *ff.font_file, font_index, &exist_unknown);
    };
    
    double scale = m_scale_height.has_value() ? *m_scale_height : 1.;
    ImFont *imgui_font = m_style_manager.get_imgui_font();
    if (imgui_font == nullptr) {
        // try create new imgui font
        double screen_scale = wxDisplay(wxGetApp().plater()).GetScaleFactor();
        double imgui_scale = scale * screen_scale;
        m_style_manager.create_imgui_font(create_range_text_prep(), imgui_scale);
        imgui_font = m_style_manager.get_imgui_font();
    }
    bool exist_font = 
        imgui_font != nullptr &&
        imgui_font->IsLoaded() &&
        imgui_font->Scale > 0.f &&
        imgui_font->ContainerAtlas != nullptr;
    // NOTE: Symbol fonts doesn't have atlas 
    // when their glyph range is out of language character range
    if (exist_font) ImGui::PushFont(imgui_font);
 
    // show warning about incorrectness view of font
    std::string warning_tool_tip;
    if (!exist_font) {
        warning_tool_tip = _u8L("The text cannot be written using the selected font. Please try choosing a different font.");
    } else {
        auto append_warning = [&warning_tool_tip](std::string t) {
            if (!warning_tool_tip.empty()) 
                warning_tool_tip += "\n";
            warning_tool_tip += t;
        };
        if (is_text_empty(m_text)) 
            append_warning(_u8L("Embossed text cannot contain only white spaces."));
        if (m_text_contain_unknown_glyph)
            append_warning(_u8L("Text contains character glyph (represented by '?') unknown by font."));
 
        const FontProp &prop = m_style_manager.get_font_prop();
        if (prop.skew.has_value())     append_warning(_u8L("Text input doesn't show font skew."));
        if (prop.boldness.has_value()) append_warning(_u8L("Text input doesn't show font boldness."));
        if (prop.line_gap.has_value()) append_warning(_u8L("Text input doesn't show gap between lines."));
        auto &ff         = m_style_manager.get_font_file_with_cache();
        float imgui_size = StyleManager::get_imgui_font_size(prop, *ff.font_file, scale);
        if (imgui_size > StyleManager::max_imgui_font_size)
            append_warning(_u8L("Too tall, diminished font height inside text input."));
        if (imgui_size < StyleManager::min_imgui_font_size)
            append_warning(_u8L("Too small, enlarged font height inside text input."));
        bool is_multiline = m_text_lines.get_lines().size() > 1;
        if (is_multiline && (prop.align.first == FontProp::HorizontalAlign::center || prop.align.first == FontProp::HorizontalAlign::right))
            append_warning(_u8L("Text doesn't show current horizontal alignment."));
    }
    
    // flag for extend font ranges if neccessary
    // ranges can't be extend during font is activ(pushed)
    std::string range_text;
    ImVec2 input_size(m_gui_cfg->text_size.x, m_gui_cfg->text_size.y);
    const ImGuiInputTextFlags flags = ImGuiInputTextFlags_AllowTabInput | ImGuiInputTextFlags_AutoSelectAll;
    if (ImGui::InputTextMultiline("##Text", &m_text, input_size, flags)) {
        if (m_style_manager.get_font_prop().per_glyph) {
            unsigned count_lines = get_count_lines(m_text);
            if (count_lines != m_text_lines.get_lines().size()) 
                // Necesarry to initialize count by given number (differ from stored in volume at the moment)
                reinit_text_lines(count_lines);         
        }
        process();
        range_text = create_range_text_prep();
    }
 
    if (exist_font) ImGui::PopFont();
 
    // warning tooltip has to be with default font
    if (!warning_tool_tip.empty()) {
        // Multiline input has hidden window for scrolling
        const ImGuiWindow *input = ImGui::GetCurrentWindow()->DC.ChildWindows.front();
        const ImGuiStyle &style = ImGui::GetStyle();
        float scrollbar_width = (input->ScrollbarY) ? style.ScrollbarSize : 0.f;
        float scrollbar_height = (input->ScrollbarX) ? style.ScrollbarSize : 0.f;
 
        if (ImGui::IsItemHovered())
            m_imgui->tooltip(warning_tool_tip, m_gui_cfg->max_tooltip_width);
 
        ImVec2 cursor = ImGui::GetCursorPos();
        float width = ImGui::GetContentRegionAvailWidth();
        const ImVec2& padding = style.FramePadding;
        ImVec2 icon_pos(width - m_gui_cfg->icon_width - scrollbar_width + padding.x, 
                        cursor.y - 2 * m_gui_cfg->icon_width - scrollbar_height - 2*padding.y);  // ORCA fix vertical position
        
        ImGui::SetCursorPos(icon_pos);
        draw(get_icon(m_icons, IconType::exclamation, IconState::hovered));
        ImGui::SetCursorPos(cursor);
    }
 
    // NOTE: must be after ImGui::font_pop() 
    //          -> imgui_font has to be unused
    // IMPROVE: only extend not clear
    // Extend font ranges
    if (!range_text.empty() &&
        !ImGuiWrapper::contain_all_glyphs(imgui_font, range_text) )
        m_style_manager.clear_imgui_font();    
}

References _u8L, Slic3r::FontProp::align, Slic3r::FontProp::boldness, Slic3r::FontProp::center, Slic3r::GUI::ImGuiWrapper::contain_all_glyphs(), Slic3r::Emboss::create_range_text(), Slic3r::GUI::draw(), anonymous_namespace{GLGizmoEmboss.cpp}::exclamation, Slic3r::Emboss::get_count_lines(), Slic3r::GUI::Emboss::StyleManager::get_imgui_font_size(), anonymous_namespace{GLGizmoEmboss.cpp}::hovered, Slic3r::FontProp::line_gap, m_gui_cfg, m_icons, Slic3r::GUI::GLGizmoBase::m_imgui, m_scale_height, m_style_manager, m_text, m_text_contain_unknown_glyph, m_text_lines, Slic3r::GUI::Emboss::StyleManager::max_imgui_font_size, Slic3r::GUI::Emboss::StyleManager::min_imgui_font_size, Slic3r::GUI::plater(), process(), reinit_text_lines(), Slic3r::FontProp::right, scale(), Slic3r::FontProp::skew, and style.

Referenced by draw_window().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ draw_window()

void GLGizmoEmboss::draw_window	(	float	x,
		float	y )

private

{
#ifdef ALLOW_DEBUG_MODE
    if (ImGui::Button("re-process")) process();
#endif //  ALLOW_DEBUG_MODE
 
    // Setter of indent must be befor disable !!!
    ImGui::PushStyleVar(ImGuiStyleVar_IndentSpacing, m_gui_cfg->indent);
    ScopeGuard indent_sc([](){ ImGui::PopStyleVar(/*ImGuiStyleVar_IndentSpacing*/); });
 
    // Disable all except selection of font, when open text from 3mf with unknown font
    m_imgui->disabled_begin(m_is_unknown_font);
    ScopeGuard unknown_font_sc([imgui = m_imgui]() { imgui->disabled_end(/*m_is_unknown_font*/); });
 
    draw_text_input();
 
    // subtract 4.0f to counteract weird additional spacing/padding of the revert buttons
    ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(10.0f, 10.0f - 4.0f));
    ScopeGuard spacing_sc([](){ ImGui::PopStyleVar(/*ImGuiStyleVar_ItemSpacing*/); });
 
    draw_style_list();
 
    // When unknown font is inside .3mf only font selection is allowed
    m_imgui->disabled_end(/*m_is_unknown_font*/);
    draw_font_list_line();
    m_imgui->disabled_begin(m_is_unknown_font);
 
    bool use_inch = wxGetApp().app_config->get_bool("use_inches");
    draw_height(use_inch);
    draw_depth(use_inch);
 
    ImGui::Spacing();
 
    // close advanced style property when unknown font is selected
    if (m_is_unknown_font && m_is_advanced_edit_style) 
        ImGui::SetNextTreeNodeOpen(false);
 
    // ImGui Bug: After switching to another window and switching back, clicking the text doesnt open/close the TreeNode anymore
    ImGuiTreeNodeFlags flags = ImGuiTreeNodeFlags_SpanAvailWidth | ImGuiTreeNodeFlags_FramePadding;
    if (ImGui::TreeNodeEx(_u8L("Advanced").c_str(), flags)) {
        if (!m_is_advanced_edit_style) {
            m_is_advanced_edit_style = true;
            m_imgui->set_requires_extra_frame();
        } else {
            draw_advanced();
        }
        ImGui::TreePop();
    } else if (m_is_advanced_edit_style) {
        m_is_advanced_edit_style = false;
        m_imgui->set_requires_extra_frame();
    }
 
    ImGui::Spacing();
 
    // Do not select volume type, when it is text object
    if (!m_volume->is_the_only_one_part()) {
        ImGui::Separator();
        draw_model_type();
    }
 
    ImGui::Spacing();
    ImGui::Separator();
    ImGui::Spacing();
    float f_scale = m_parent.get_gizmos_manager().get_layout_scale();
    ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(6.0f, 4.0f * f_scale));
 
    GLGizmoUtils::render_tooltip_button(m_imgui, m_parent, m_shortcuts, x, y);
 
    ImGui::SameLine();
    m_imgui->disabled_begin(is_changed_from_default_style());
    if (m_imgui->button(_L("Reset"), _L("Reset all options except the text and operation"))) {
        reset_to_default_style();
    }
    m_imgui->disabled_end();
 
    ImGui::SameLine();
    GLGizmoUtils::begin_right_aligned_buttons({_L("Done")});
 
    if (m_imgui->button(_L("Done"))) {
        m_parent.reset_all_gizmos();
    }
 
    ImGui::PopStyleVar(1); // ImGuiStyleVar_FramePadding
       
#ifdef SHOW_WX_FONT_DESCRIPTOR
    if (is_selected_style)
        m_imgui->text_colored(ImGuiWrapper::COL_GREY_DARK, m_style_manager.get_style().path);
#endif // SHOW_WX_FONT_DESCRIPTOR
 
#ifdef SHOW_CONTAIN_3MF_FIX
    if (m_volume!=nullptr &&
        m_volume->text_configuration.has_value() &&
        m_volume->text_configuration->fix_3mf_tr.has_value()) {
        ImGui::SameLine();
        m_imgui->text_colored(ImGuiWrapper::COL_GREY_DARK, ".3mf");
        if (ImGui::IsItemHovered()) {
            Transform3d &fix = *m_volume->text_configuration->fix_3mf_tr;
            std::stringstream ss;
            ss << fix.matrix();            
            std::string filename = (m_volume->source.input_file.empty())? "unknown.3mf" :
                                   m_volume->source.input_file + ".3mf";
            ImGui::SetTooltip("Text configuation contain \n"
                              "Fix Transformation Matrix \n"
                              "%s\n"
                              "loaded from \"%s\" file.",
                              ss.str().c_str(), filename.c_str()
                );
        }
    }
#endif // SHOW_CONTAIN_3MF_FIX
#ifdef SHOW_ICONS_TEXTURE    
    auto &t = m_icons_texture;
    ImGui::Image((void *) t.get_id(), ImVec2(t.get_width(), t.get_height()));
#endif //SHOW_ICONS_TEXTURE
#ifdef SHOW_IMGUI_ATLAS
    const auto &atlas = m_style_manager.get_atlas();
    ImGui::Image(atlas.TexID, ImVec2(atlas.TexWidth, atlas.TexHeight));
#endif // SHOW_IMGUI_ATLAS
 
#ifdef ALLOW_OPEN_NEAR_VOLUME
    ImGui::SameLine();
    if (ImGui::Checkbox("##ALLOW_OPEN_NEAR_VOLUME", &m_allow_open_near_volume)) {
        if (m_allow_open_near_volume)
            m_set_window_offset = calc_fine_position(m_parent.get_selection(), get_minimal_window_size(), m_parent.get_canvas_size());
    } else if (ImGui::IsItemHovered()) {
        ImGui::SetTooltip("%s", ((m_allow_open_near_volume) ? 
            "Fix settings position":
            "Allow floating window near text").c_str());
    }
#endif // ALLOW_FLOAT_WINDOW
 }

References _L, _u8L, Slic3r::GUI::GLGizmoUtils::begin_right_aligned_buttons(), Slic3r::GUI::ImGuiWrapper::COL_GREY_DARK, draw_advanced(), draw_depth(), draw_font_list_line(), draw_height(), draw_model_type(), draw_style_list(), draw_text_input(), is_changed_from_default_style(), m_gui_cfg, Slic3r::GUI::GLGizmoBase::m_imgui, m_is_advanced_edit_style, m_is_unknown_font, Slic3r::GUI::GLGizmoBase::m_parent, m_shortcuts, m_style_manager, m_volume, process(), Slic3r::GUI::GLGizmoUtils::render_tooltip_button(), and reset_to_default_style().

Referenced by on_render_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ format()

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

protectedinherited

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

References Slic3r::string_printf().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_action_snapshot_name()

std::string GLGizmoEmboss::get_action_snapshot_name ( ) const

overrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

807{ return _u8L("Embossing actions"); }

References _u8L.

◆ get_count()

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

inlineinherited

224{ return ++count; }

Slic3r::GUI::GLGizmoBase::count

int count

Definition GLGizmoBase.hpp:294

References count.

◆ get_gizmo_entering_text()

std::string GLGizmoEmboss::get_gizmo_entering_text ( ) const

overrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

805{ return _u8L("Enter emboss gizmo"); }

References _u8L.

◆ get_gizmo_leaving_text()

std::string GLGizmoEmboss::get_gizmo_leaving_text ( ) const

overrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

806{ return _u8L("Leave emboss gizmo"); }

References _u8L.

◆ get_gizmo_name()

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

inlineinherited

225{ return on_get_name(); }

Slic3r::GUI::GLGizmoBase::on_get_name

virtual std::string on_get_name() const =0

References on_get_name().

Here is the call graph for this function:

◆ get_hover_id()

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

inlineinherited

206{ return m_hover_id; }

Slic3r::GUI::GLGizmoBase::m_hover_id

int m_hover_id

Definition GLGizmoBase.hpp:150

References m_hover_id.

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

Here is the caller graph for this function:

◆ get_icon_filename()

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

inlineinherited

180{ return m_icon_filename; }

Slic3r::GUI::GLGizmoBase::m_icon_filename

std::string m_icon_filename

Definition GLGizmoBase.hpp:148

References m_icon_filename.

◆ get_name()

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

inherited

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

References m_shortcut, and on_get_name().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_requirements()

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

inlineinherited

186{ return on_get_requirements(); }

Slic3r::GUI::GLGizmoBase::on_get_requirements

virtual CommonGizmosDataID on_get_requirements() const

Definition GLGizmoBase.hpp:248

References on_get_requirements().

Here is the call graph for this function:

◆ get_sprite_id()

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

inlineinherited

204{ return m_sprite_id; }

Slic3r::GUI::GLGizmoBase::m_sprite_id

unsigned int m_sprite_id

Definition GLGizmoBase.hpp:149

References m_sprite_id.

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

Here is the caller graph for this function:

◆ get_state()

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

inlineinherited

175{ return m_state; }

Slic3r::GUI::GLGizmoBase::m_state

EState m_state

Definition GLGizmoBase.hpp:146

References m_state.

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

Here is the caller graph for this function:

◆ get_tooltip()

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

inlinevirtualinherited

Mouse tooltip text.

Returns: Text to be visible in mouse tooltip

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

222{ return ""; }

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

Here is the caller graph for this function:

◆ GizmoImguiBegin()

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

protectedinherited

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

References m_imgui.

Here is the caller graph for this function:

◆ GizmoImguiEnd()

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

protectedinherited

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

References last_input_window_width, and m_imgui.

Here is the caller graph for this function:

◆ GizmoImguiSetNextWIndowPos() [1/2]

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

protectedinherited

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

References m_imgui, and m_parent.

◆ GizmoImguiSetNextWIndowPos() [2/2]

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

protectedinherited

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

References GizmoImguiSetNextWIndowPos(), and last_input_window_width.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ init()

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

inlineinherited

168{ return on_init(); }

Slic3r::GUI::GLGizmoBase::on_init

virtual bool on_init()=0

References on_init().

Here is the call graph for this function:

◆ init_create()

bool GLGizmoEmboss::init_create ( ModelVolumeType volume_type )

private

{
    // check valid volume type
    if (!check(volume_type)){    
        BOOST_LOG_TRIVIAL(error) << "Can't create embossed volume with this type: " << (int) volume_type;
        return false;
    }
 
    if (!is_activable()) {
        BOOST_LOG_TRIVIAL(error) << "Can't create text. Gizmo is not activabled.";
        return false;
    }
 
    // Check can't be inside is_activable() cause crash
    // steps to reproduce: start App -> key 't' -> key 'delete'
    if (wxGetApp().obj_list()->has_selected_cut_object()) {
        BOOST_LOG_TRIVIAL(error) << "Can't create text on cut object";
        return false;
    }
 
    m_style_manager.discard_style_changes();
 
    // set default text, in English when the active font cannot write its translation
    m_text = _u8L(default_text);
    if (m_style_manager.is_active_font() && !can_write(m_style_manager, m_text))
        m_text = default_text;
    return true;
}

References _u8L, Slic3r::GUI::GLGizmoBase::is_activable(), m_style_manager, m_text, and Slic3r::GUI::obj_list().

Referenced by create_volume(), and create_volume().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ init_font_name_texture()

void GLGizmoEmboss::init_font_name_texture ( )

private

                                           {
    Timer t("init_font_name_texture");
    // check if already exists
    GLuint &id = m_face_names->texture_id; 
    if (id != 0) return;
    // create texture for font
    GLenum target = GL_TEXTURE_2D;
    glsafe(::glGenTextures(1, &id));
    glsafe(::glBindTexture(target, id));
    glsafe(::glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST));
    glsafe(::glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST));
    const Vec2i32 &size = m_gui_cfg->face_name_size;
    GLint w = size.x(), h = m_face_names->count_cached_textures * size.y();
    std::vector<unsigned char> data(4*w * h, {0});
    const GLenum format = GL_RGBA, type = GL_UNSIGNED_BYTE;
    const GLint level = 0, internal_format = GL_RGBA, border = 0;
    glsafe(::glTexImage2D(target, level, internal_format, w, h, border, format, type, data.data()));
 
    // bind default texture
    GLuint no_texture_id = 0;
    glsafe(::glBindTexture(target, no_texture_id));
 
    // clear info about creation of texture - no one is initialized yet
    for (FaceName &face : m_face_names->faces) { 
        face.cancel = nullptr;
        face.is_created = nullptr;
    }
 
    // Prepare filtration cache
    //m_face_names->hide = std::vector<bool>(m_face_names->faces.size(), {false});
}

References Slic3r::GUI::GLGizmoBase::format(), GL_NEAREST, GL_RGBA, GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_TEXTURE_MIN_FILTER, GL_UNSIGNED_BYTE, glBindTexture, glGenTextures, glsafe, glTexImage2D, glTexParameteri, m_face_names, and m_gui_cfg.

Referenced by draw_font_list().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ init_icons()

void GLGizmoEmboss::init_icons ( )

private

{
    // icon order has to match the enum IconType
    std::vector<std::string> filenames{
        "edit_button.svg",
        "delete.svg",
        "add_copies.svg", 
        "save.svg", 
        "undo.svg",    
        "make_italic.svg",
        "make_unitalic.svg",
        "make_bold.svg",
        "make_unbold.svg",   
        "search.svg",
        "open.svg", 
        "obj_warning.svg",  // ORCA: use obj_warning instead exclamation. exclamation is not compatible with low res
        "lock_closed.svg",  // lock,
        "lock_closed_f.svg",// lock_bold,
        "lock_open.svg",    // unlock,
        "lock_open_f.svg",  // unlock_bold,
        "align_horizontal_left.svg", 
        "align_horizontal_center.svg",
        "align_horizontal_right.svg",
        "align_vertical_top.svg",
        "align_vertical_center.svg",
        "align_vertical_bottom.svg"
    };
    assert(filenames.size() == static_cast<size_t>(IconType::_count));
    std::string path = resources_dir() + "/images/";
    for (std::string &filename : filenames) filename = path + filename;
 
    ImVec2 size(m_gui_cfg->icon_width, m_gui_cfg->icon_width);
    auto type = IconManager::RasterType::color_wite_gray;
    m_icons = m_icon_manager.init(filenames, size, type);
}

References anonymous_namespace{GLGizmoEmboss.cpp}::_count, Slic3r::GUI::IconManager::color_wite_gray, m_gui_cfg, m_icon_manager, m_icons, and Slic3r::resources_dir().

Referenced by on_render_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_activable()

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

inlineinherited

184{ return on_is_activable(); }

Slic3r::GUI::GLGizmoBase::on_is_activable

virtual bool on_is_activable() const

Definition GLGizmoBase.hpp:246

References on_is_activable().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_changed_from_default_style()

bool GLGizmoEmboss::is_changed_from_default_style ( )

private

{
    int                        default_index = 0;
    const StyleManager::Style& default_style = m_style_manager.get_styles()[default_index];
    const StyleManager::Style& current_style = m_style_manager.get_style();
 
    return default_style == current_style;
}

References m_style_manager.

Referenced by draw_window().

Here is the caller graph for this function:

◆ is_dragging()

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

inlineinherited

209{ return m_dragging; }

References m_dragging.

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

Here is the caller graph for this function:

◆ is_in_editing_mode()

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

inlinevirtualinherited

Reimplemented in Slic3r::GUI::GLGizmoCut3D.

235{ return false; }

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

Here is the caller graph for this function:

◆ is_selectable()

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

inlineinherited

185{ return on_is_selectable(); }

Slic3r::GUI::GLGizmoBase::on_is_selectable

virtual bool on_is_selectable() const

Definition GLGizmoBase.hpp:247

References on_is_selectable().

Here is the call graph for this function:

◆ is_selection_rectangle_dragging()

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

inlinevirtualinherited

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

236{ return false; }

◆ load()

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

inlineinherited

170{ m_state = On; on_load(ar); }

Slic3r::GUI::GLGizmoBase::on_load

virtual void on_load(cereal::BinaryInputArchive &ar)

Definition GLGizmoBase.hpp:241

References m_state, On, and on_load().

Here is the call graph for this function:

◆ load_render_colors()

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

staticinherited

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ on_change_color_mode()

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

inlinevirtualinherited

216{ m_is_dark_mode = is_dark; }

is_dark

static bool is_dark()

Definition TextureImportDialog.cpp:85

Slic3r::GUI::GLGizmoBase::m_is_dark_mode

bool m_is_dark_mode

Definition GLGizmoBase.hpp:157

References is_dark(), and m_is_dark_mode.

Here is the call graph for this function:

◆ on_disable_grabber()

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

inlineoverrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

89{ m_rotate_gizmo.disable_grabber(); }

References m_rotate_gizmo.

◆ on_dragging()

void GLGizmoEmboss::on_dragging ( const UpdateData & data )

overrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

1070{ m_rotate_gizmo.dragging(data); }

References m_rotate_gizmo.

◆ on_enable_grabber()

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

inlineoverrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

88{ m_rotate_gizmo.enable_grabber(); }

References m_rotate_gizmo.

◆ on_get_name()

std::string GLGizmoEmboss::on_get_name ( ) const

overrideprotectedvirtual

Implements Slic3r::GUI::GLGizmoBase.

830{ return _u8L("Emboss"); }

References _u8L.

◆ on_get_requirements()

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

inlineprotectedvirtualinherited

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

248{ return CommonGizmosDataID(0); }

Slic3r::GUI::CommonGizmosDataID

CommonGizmosDataID

Definition GLGizmosCommon.hpp:72

Referenced by get_requirements().

Here is the caller graph for this function:

◆ on_init()

bool GLGizmoEmboss::on_init ( )

overrideprotectedvirtual

Implements Slic3r::GUI::GLGizmoBase.

{
    m_rotate_gizmo.init();
    ColorRGBA gray_color(.6f, .6f, .6f, .3f);
    m_rotate_gizmo.set_highlight_color(gray_color);
 
    // NOTE: It has special handling in GLGizmosManager::handle_shortcut
    m_shortcut = Shortcut::GizmoEmboss;
 
    m_shortcuts = {
        {_L("Drag"),        _L("Position on surface")}
    };
 
    // initialize text styles
    m_style_manager.init(wxGetApp().app_config);
 
    // Set rotation gizmo upwardrotate
    m_rotate_gizmo.set_angle(PI / 2);
    return true;
}

References _L, Slic3r::GUI::GizmoEmboss, m_rotate_gizmo, Slic3r::GUI::GLGizmoBase::m_shortcut, m_shortcuts, m_style_manager, and PI.

◆ on_is_activable()

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

inlineprotectedvirtualinherited

Reimplemented in Slic3r::GUI::GLGizmoAssembly, Slic3r::GUI::GLGizmoBrimEars, Slic3r::GUI::GLGizmoCut3D, Slic3r::GUI::GLGizmoFlatten, Slic3r::GUI::GLGizmoMeasure, Slic3r::GUI::GLGizmoMeshBoolean, Slic3r::GUI::GLGizmoMmuSegmentation, Slic3r::GUI::GLGizmoMove3D, Slic3r::GUI::GLGizmoPainterBase, Slic3r::GUI::GLGizmoRotate3D, Slic3r::GUI::GLGizmoScale3D, Slic3r::GUI::GLGizmoSimplify, Slic3r::GUI::GLGizmoSVG, and Slic3r::GUI::GLGizmoTextureDisplacement.

246{ return true; }

Referenced by is_activable().

Here is the caller graph for this function:

◆ on_is_selectable()

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

inlineprotectedvirtualinherited

Reimplemented in Slic3r::GUI::GLGizmoCut3D, Slic3r::GUI::GLGizmoMmuSegmentation, Slic3r::GUI::GLGizmoPainterBase, Slic3r::GUI::GLGizmoSimplify, and Slic3r::GUI::GLGizmoSVG.

247{ return true; }

Referenced by is_selectable().

Here is the caller graph for this function:

◆ on_load()

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

inlineprotectedvirtualinherited

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

241{}

Referenced by load().

Here is the caller graph for this function:

◆ on_mouse()

bool GLGizmoEmboss::on_mouse ( const wxMouseEvent & mouse_event )

overrideprotectedvirtual

Rotate by text on dragging rotate grabers.

Parameters

mouse_event Information about mouse

Returns: Propagete normaly return false.

Reimplemented from Slic3r::GUI::GLGizmoBase.

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

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

Here is the call graph for this function:

◆ on_mouse_change_selection()

void GLGizmoEmboss::on_mouse_change_selection ( const wxMouseEvent & mouse_event )

private

{
    static bool was_dragging = true;
    // The left up may be the end of a drag that started on the gizmo floating window (e.g. selecting
    // text in the input field). Such a release is not a click on the scene and must not close the gizmo.
    // (The flag is only set for left up events, so right up behavior is unchanged.)
    if ((mouse_event.LeftUp() || mouse_event.RightUp()) && !was_dragging && !m_parent.is_mouse_left_up_ignored()) {
        // is hovered volume closest hovered?
        int hovered_idx = m_parent.get_first_hover_volume_idx();
        if (hovered_idx < 0) 
            // unselect object
            return close();
 
        const GLVolumePtrs &gl_volumes = m_parent.get_volumes().volumes;
        auto hovered_idx_ = static_cast<size_t>(hovered_idx);
        if (hovered_idx_ >= gl_volumes.size())
            return close();
        
        const GLVolume *gl_volume = gl_volumes[hovered_idx_];
        if (gl_volume == nullptr)
            return close();
 
        const ModelVolume *volume = get_model_volume(*gl_volume, m_parent.get_model()->objects);
        if (volume == nullptr || !volume->text_configuration.has_value())
            // select volume without text configuration
            return close();
 
        // Reselection of text to another text
    }
    was_dragging = mouse_event.Dragging();
 
    // Hook When click on object for reselection must be on event left down not up
    if (mouse_event.LeftDown()) {
        // is hovered volume closest hovered?
        int hovered_idx = m_parent.get_first_hover_volume_idx();
        if (hovered_idx < 0)
            // Potentionaly move with camera (drag)
            return;
 
        const GLVolumePtrs &gl_volumes = m_parent.get_volumes().volumes;
        auto hovered_idx_ = static_cast<size_t>(hovered_idx);
        if (hovered_idx_ >= gl_volumes.size())
            return;
        const GLVolume *gl_volume = gl_volumes[hovered_idx_];
        if (gl_volume == nullptr)
            return;
        const ModelVolume *volume = get_model_volume(*gl_volume, m_parent.get_model()->objects);
        if (volume == nullptr)
            return;
 
        if (volume->text_configuration.has_value())        
            return; // Reselection of text to another text
 
        // select volume without text configuration
        return close();
    }
 
    // Hook When drag with scene by right mouse button
    // object it is selected after drag scene !!
    if (mouse_event.RightDown()) {
        // is hovered volume closest hovered?
        int hovered_idx = m_parent.get_first_hover_volume_idx();
        if (hovered_idx < 0)
            // Potentionaly move with camera (drag)
            return;
 
        const GLVolumePtrs &gl_volumes = m_parent.get_volumes().volumes;
        auto hovered_idx_ = static_cast<size_t>(hovered_idx);
        if (hovered_idx_ >= gl_volumes.size())
            return;
        const GLVolume *gl_volume = gl_volumes[hovered_idx_];
        if (gl_volume == nullptr)
            return;
        const ModelVolume *volume = get_model_volume(*gl_volume, m_parent.get_model()->objects);
        if (volume == nullptr)
            return;
 
        // is actual selected?
        if (m_volume->id() == volume->id())
            return;
 
        // select volume without text configuration
        return close();
    }
}

References close(), Slic3r::GUI::get_model_volume(), Slic3r::ObjectBase::id(), Slic3r::GUI::GLGizmoBase::m_parent, m_volume, Slic3r::ModelVolume::text_configuration, and Slic3r::GUI::wxMouseEvent.

Referenced by on_mouse().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ on_mouse_for_rotation()

bool GLGizmoEmboss::on_mouse_for_rotation ( const wxMouseEvent & mouse_event )

private

{
    if (mouse_event.Moving()) return false;
 
    bool used = use_grabbers(mouse_event);
    if (!m_dragging) return used;
 
    if (mouse_event.Dragging()) {
        // check that style is activ
        assert(m_style_manager.is_active_font());
        if (!m_style_manager.is_active_font())
            return used;
 
        std::optional<float> &angle_opt = m_style_manager.get_style().angle;
        dragging_rotate_gizmo(m_rotate_gizmo.get_angle(), angle_opt, m_rotate_start_angle, m_parent.get_selection());
    }
    return used;
}

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

Referenced by on_mouse().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ on_mouse_for_translate()

bool GLGizmoEmboss::on_mouse_for_translate ( const wxMouseEvent & mouse_event )

private

{
    // exist selected volume?
    if (m_volume == nullptr)
        return false;
    
    const Camera &camera = wxGetApp().plater()->get_camera();
    bool was_dragging = m_surface_drag.has_value();
    bool res = on_mouse_surface_drag(mouse_event, camera, m_surface_drag, m_parent, m_raycast_manager, UP_LIMIT);
    bool is_dragging = m_surface_drag.has_value();
 
    // End with surface dragging?
    if (was_dragging && !is_dragging) 
        volume_transformation_changed();
    
    // Start with dragging
    else if (!was_dragging && is_dragging) {
        // Cancel job to prevent interuption of dragging (duplicit result)
        if (m_job_cancel != nullptr)
            m_job_cancel->store(true);
    }
 
    // during drag
    else if (was_dragging && is_dragging) {
        // update scale of selected volume --> should be approx the same
        calculate_scale();
 
        // Recalculate angle for GUI
        if (!m_keep_up) {
            const Selection &selection = m_parent.get_selection();
            const GLVolume *gl_volume = get_selected_gl_volume(selection);
            assert(gl_volume != nullptr);
            assert(m_style_manager.is_active_font());
            if (gl_volume == nullptr || !m_style_manager.is_active_font())
                return res;
            m_style_manager.get_style().angle = calc_angle(selection);
        }
 
        volume_transformation_changing();
    }
    return res;
}

References Slic3r::GUI::calc_angle(), calculate_scale(), Slic3r::GUI::get_selected_gl_volume(), Slic3r::GUI::GLGizmoBase::is_dragging(), m_job_cancel, m_keep_up, Slic3r::GUI::GLGizmoBase::m_parent, m_raycast_manager, m_style_manager, m_surface_drag, m_volume, Slic3r::GUI::on_mouse_surface_drag(), Slic3r::GUI::UP_LIMIT, volume_transformation_changed(), volume_transformation_changing(), and Slic3r::GUI::wxMouseEvent.

Referenced by on_mouse().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ on_register_raycasters_for_picking()

void GLGizmoEmboss::on_register_raycasters_for_picking ( )

overrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

                                                      {
    m_rotate_gizmo.register_raycasters_for_picking();
}

References m_rotate_gizmo.

◆ on_render()

void GLGizmoEmboss::on_render ( )

overrideprotectedvirtual

Implements Slic3r::GUI::GLGizmoBase.

                              {
    // no volume selected
    const Selection &selection = m_parent.get_selection();
    if (m_volume == nullptr ||
        get_model_volume(m_volume_id, selection.get_model()->objects) == nullptr)
        return;
    if (selection.is_empty()) return;
 
    // prevent get local coordinate system on multi volumes
    if (!selection.is_single_volume_or_modifier() && 
        !selection.is_single_volume_instance()) return;
    
    const GLVolume *gl_volume_ptr = m_parent.get_selection().get_first_volume();
    if (gl_volume_ptr == nullptr) return;
 
    if (m_text_lines.is_init()) {
        const Transform3d& tr = gl_volume_ptr->world_matrix();
        const auto &fix = m_volume->emboss_shape->fix_3mf_tr;
        if (fix.has_value()) 
            m_text_lines.render(tr * fix->inverse());
        else 
            m_text_lines.render(tr);
    }
 
    bool is_surface_dragging = m_surface_drag.has_value();
    bool is_parent_dragging = m_parent.is_mouse_dragging();
    // Do NOT render rotation grabbers when dragging object
    bool is_rotate_by_grabbers = m_dragging;
    if (is_rotate_by_grabbers || 
        (!is_surface_dragging && !is_parent_dragging)) {
        glsafe(::glClear(GL_DEPTH_BUFFER_BIT));
        m_rotate_gizmo.render();
    }
}

References Slic3r::GUI::Selection::get_model(), Slic3r::GUI::get_model_volume(), GL_DEPTH_BUFFER_BIT, glClear, glsafe, Slic3r::GUI::Selection::is_empty(), Slic3r::GUI::Selection::is_single_volume_instance(), Slic3r::GUI::Selection::is_single_volume_or_modifier(), Slic3r::GUI::GLGizmoBase::m_dragging, Slic3r::GUI::GLGizmoBase::m_parent, m_rotate_gizmo, m_surface_drag, m_text_lines, m_volume, m_volume_id, Slic3r::Model::objects, and Slic3r::GLVolume::world_matrix().

Here is the call graph for this function:

◆ on_render_input_window()

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

overrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

{
    assert(m_volume != nullptr);
    // Do not render window for not selected text volume
    if (m_volume == nullptr ||
        get_model_volume(m_volume_id, m_parent.get_selection().get_model()->objects) == nullptr ||
        !m_volume->text_configuration.has_value()) {
        // This closing could lead to bad behavior of undo/redo stack when unselection create snapshot before close
        close();
        return;
    }
 
    // Not known situation when could happend this is only for sure
    if (!m_is_unknown_font && !m_style_manager.is_active_font())
        create_notification_not_valid_font(_u8L("No active font in style. Select correct one."));
    else if (!m_is_unknown_font && !m_style_manager.get_wx_font().IsOk())
        create_notification_not_valid_font(_u8L("WxFont is not loaded properly."));
 
    double screen_scale = wxDisplay(wxGetApp().plater()).GetScaleFactor();
 
    // Orca
    ImGuiWrapper::push_toolbar_style(m_parent.get_scale());
    ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(4.0, 5.0) * screen_scale);
    ImGui::PushStyleVar(ImGuiStyleVar_ScrollbarSize, 4.0f * screen_scale);
 
    // Configuration creation
    if (m_gui_cfg == nullptr ||                   // Exist configuration - first run
        m_gui_cfg->screen_scale != screen_scale  ||// change of DPI
        m_gui_cfg->dark_mode != m_is_dark_mode // change of dark mode
        ) {
        // Create cache for gui offsets
        ::GuiCfg cfg = create_gui_configuration();
        cfg.screen_scale = screen_scale;
        cfg.dark_mode    = m_is_dark_mode;
 
        GuiCfg gui_cfg{std::move(cfg)};
        m_gui_cfg = std::make_unique<const GuiCfg>(std::move(gui_cfg));
 
        // change resolution regenerate icons
        init_icons();
        m_style_manager.clear_imgui_font();
    }
 
    // Draw origin position of text during dragging
    if (m_surface_drag.has_value()) {
        ImVec2 mouse_pos = ImGui::GetMousePos();
        ImVec2 center(
            mouse_pos.x + m_surface_drag->mouse_offset.x(),
            mouse_pos.y + m_surface_drag->mouse_offset.y());
        ImU32 color = ImGui::GetColorU32(
            m_surface_drag->exist_hit ? 
                ImVec4(1.f, 1.f, 1.f, .75f) : // transparent white
                ImVec4(1.f, .3f, .3f, .75f)
        ); // Warning color
        const float radius = 16.f;
        ImGuiWrapper::draw_cross_hair(center, radius, color);
    }
 
#ifdef SHOW_FINE_POSITION
    draw_fine_position(m_parent.get_selection(), m_parent.get_canvas_size(), min_window_size);
#endif // SHOW_FINE_POSITION
#ifdef DRAW_PLACE_TO_ADD_TEXT
    draw_place_to_add_text();
#endif // DRAW_PLACE_TO_ADD_TEXT
#ifdef SHOW_OFFSET_DURING_DRAGGING
    draw_mouse_offset(m_dragging_mouse_offset);
#endif // SHOW_OFFSET_DURING_DRAGGING
 
    static float last_y = 0.0f;
    static float last_h = 0.0f;
 
    // adjust window position to avoid overlap the view toolbar
    const float win_h = ImGui::GetWindowHeight();
    y = std::min(y, bottom_limit - win_h);
    GizmoImguiSetNextWIndowPos(x, y, ImGuiCond_Always, 0.0f, 0.0f);
    if (last_h != win_h || last_y != y) {
        // ask canvas for another frame to render the window in the correct position
        m_imgui->set_requires_extra_frame();
        if (last_h != win_h)
            last_h = win_h;
        if (last_y != y)
            last_y = y;
    }
    
    GizmoImguiBegin(get_name(), ImGuiWindowFlags_NoMove | ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar);
 
    draw_window(x, y);
 
    GizmoImguiEnd();
 
    // Orca
    ImGui::PopStyleVar(2);
    ImGuiWrapper::pop_toolbar_style();
}

References _u8L, Slic3r::center(), close(), create_notification_not_valid_font(), Slic3r::GUI::ImGuiWrapper::draw_cross_hair(), draw_window(), Slic3r::GUI::get_model_volume(), Slic3r::GUI::GLGizmoBase::get_name(), Slic3r::GUI::GLGizmoBase::GizmoImguiBegin(), Slic3r::GUI::GLGizmoBase::GizmoImguiEnd(), Slic3r::GUI::GLGizmoBase::GizmoImguiSetNextWIndowPos(), init_icons(), m_gui_cfg, Slic3r::GUI::GLGizmoBase::m_imgui, Slic3r::GUI::GLGizmoBase::m_is_dark_mode, m_is_unknown_font, Slic3r::GUI::GLGizmoBase::m_parent, m_style_manager, m_surface_drag, m_volume, m_volume_id, Slic3r::GUI::plater(), Slic3r::GUI::ImGuiWrapper::pop_toolbar_style(), and Slic3r::GUI::ImGuiWrapper::push_toolbar_style().

Here is the call graph for this function:

◆ on_save()

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

inlineprotectedvirtualinherited

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

242{}

Referenced by save().

Here is the caller graph for this function:

◆ on_set_hover_id()

void Slic3r::GUI::GLGizmoEmboss::on_set_hover_id ( )

inlineoverrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

87{ m_rotate_gizmo.set_hover_id(m_hover_id); }

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

◆ on_set_state()

void GLGizmoEmboss::on_set_state ( )

overrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

{
    // enable / disable bed from picking
    // Rotation gizmo must work through bed
    m_parent.set_raycaster_gizmos_on_top(m_state == GLGizmoBase::On);
 
    m_rotate_gizmo.set_state(m_state);
 
    // Closing gizmo. e.g. selecting another one
    if (m_state == GLGizmoBase::Off) {
        // refuse outgoing during text preview
        reset_volume();
        // Store order and last activ index into app.ini
        // TODO: what to do when can't store into file?
        m_style_manager.store_styles_to_app_config(false);
        remove_notification_not_valid_font();
    } else if (m_state == GLGizmoBase::On) {
        // to reload fonts from system, when install new one
        wxFontEnumerator::InvalidateCache();
 
        // Immediately after set state On is called function data_changed(), 
        // where one could distiguish undo/redo serialization from opening by letter 'T'
        // set_volume_by_selection();
    }
}

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

Here is the call graph for this function:

◆ on_shortcut_key()

void GLGizmoEmboss::on_shortcut_key ( )

Handle pressing of shortcut.

                                    {
    set_volume_by_selection();
    if (m_volume == nullptr) {
        // No volume to select from selection so create volume.
        // NOTE: After finish job for creation emboss Text volume,
        // GLGizmoEmboss will be opened
        create_volume(ModelVolumeType::MODEL_PART);
    }
    else {
        // shortcut is pressed when text is selected soo start edit it.
        auto& mng = m_parent.get_gizmos_manager();
        if (mng.get_current_type() != GLGizmosManager::Emboss)
            mng.open_gizmo(GLGizmosManager::Emboss);
    }
}

References create_volume(), Slic3r::GUI::GLGizmosManager::Emboss, Slic3r::GUI::GLGizmoBase::m_parent, m_volume, Slic3r::MODEL_PART, and set_volume_by_selection().

Here is the call graph for this function:

◆ on_start_dragging()

void GLGizmoEmboss::on_start_dragging ( )

overrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

1056{ m_rotate_gizmo.start_dragging(); }

References m_rotate_gizmo.

◆ on_stop_dragging()

void GLGizmoEmboss::on_stop_dragging ( )

overrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

{
    m_rotate_gizmo.stop_dragging();
 
    // This is fast fix for second try to rotate
    // When fixing, move grabber above text (not on side)
    m_rotate_gizmo.set_angle(PI/2);
 
    // apply rotation
    m_parent.do_rotate(rotation_snapshot_name);
    m_rotate_start_angle.reset();
    volume_transformation_changed();
}

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

Here is the call graph for this function:

◆ on_unregister_raycasters_for_picking()

void GLGizmoEmboss::on_unregister_raycasters_for_picking ( )

overrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

                                                        {
    m_rotate_gizmo.unregister_raycasters_for_picking();
}

References m_rotate_gizmo.

◆ pop_button_style()

void GLGizmoEmboss::pop_button_style ( )

protected

{
    ImGui::PopStyleColor(4);
}

◆ process()

bool GLGizmoEmboss::process ( bool make_snapshot = true )

private

{
    // no volume is selected -> selection from right panel
    assert(m_volume != nullptr);
    if (m_volume == nullptr) return false;
 
    // without text there is nothing to emboss
    if (is_text_empty(m_text)) return false;
 
    // exist loaded font file?
    if (!m_style_manager.is_active_font()) return false;
 
    const Selection& selection = m_parent.get_selection();
    DataBasePtr base = create_emboss_data_base(m_text, m_style_manager, m_text_lines, selection, m_volume->type(), m_job_cancel);
    DataUpdate  data{std::move(base), m_volume->id(), make_snapshot};
 
    // check valid count of text lines
    assert(data.base->text_lines.empty() || data.base->text_lines.size() == get_count_lines(m_text));
 
    if (!start_update_volume(std::move(data), *m_volume, selection, m_raycast_manager))
        return false;
 
    // notification is removed befor object is changed by job
    remove_notification_not_valid_font();
    return true;
}

References Slic3r::GUI::Emboss::DataUpdate::base, Slic3r::Emboss::get_count_lines(), m_job_cancel, Slic3r::GUI::GLGizmoBase::m_parent, m_raycast_manager, m_style_manager, m_text, m_text_lines, m_volume, remove_notification_not_valid_font(), Slic3r::GUI::Emboss::start_update_volume(), and Slic3r::GUI::Emboss::DataBase::text_lines.

Referenced by do_mirror(), draw_advanced(), draw_delete_style_button(), draw_depth(), draw_font_list(), draw_font_list_line(), draw_height(), draw_model_type(), draw_style_list(), draw_text_input(), draw_window(), reset_to_default_style(), select_facename(), and volume_transformation_changed().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ push_button_style()

void GLGizmoEmboss::push_button_style ( bool pressed )

protected

{
    if (m_is_dark_mode) {
        if (pressed) {
            ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(43 / 255.f, 64 / 255.f, 54 / 255.f, 1.f));
            ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(43 / 255.f, 64 / 255.f, 54 / 255.f, 1.f));
            ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4(43 / 255.f, 64 / 255.f, 54 / 255.f, 1.f));
            ImGui::PushStyleColor(ImGuiCol_Border, ImVec4(0.f, 174 / 255.f, 66 / 255.f, 1.f));
        }
        else {
            ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(45.f / 255.f, 45.f / 255.f, 49.f / 255.f, 1.f));
            ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(84 / 255.f, 84 / 255.f, 90 / 255.f, 1.f));
            ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4(84 / 255.f, 84 / 255.f, 90 / 255.f, 1.f));
            ImGui::PushStyleColor(ImGuiCol_Border, ImVec4(45.f / 255.f, 45.f / 255.f, 49.f / 255.f, 1.f));
        }
    }
    else {
        if (pressed) {
            ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(219 / 255.f, 253 / 255.f, 231 / 255.f, 1.f));
            ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(219 / 255.f, 253 / 255.f, 231 / 255.f, 1.f));
            ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4(219 / 255.f, 253 / 255.f, 231 / 255.f, 1.f));
            ImGui::PushStyleColor(ImGuiCol_Border, ImVec4(0.f, 174 / 255.f, 66 / 255.f, 1.f));
        }
        else {
            ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(1.f, 1.f, 1.f, 1.f));
            ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(238 / 255.f, 238 / 255.f, 238 / 255.f, 1.f));
            ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4(238 / 255.f, 238 / 255.f, 238 / 255.f, 1.f));
            ImGui::PushStyleColor(ImGuiCol_Border, ImVec4(1.f, 1.f, 1.f, 1.f));
        }
    
    }
}

References Slic3r::GUI::GLGizmoBase::m_is_dark_mode.

◆ re_emboss()

bool GLGizmoEmboss::re_emboss	(	const ModelVolume &	text,
		std::shared_ptr< std::atomic< bool > >	job_cancel = nullptr )

static

Call on change inside of object conatining projected volume.

Parameters

job_cancel Way to stop re_emboss job

Returns: True on success otherwise False

{
    assert(text_volume.text_configuration.has_value());
    assert(text_volume.emboss_shape.has_value());
    if (!text_volume.text_configuration.has_value() || 
        !text_volume.emboss_shape.has_value())
        return false; // not valid text volume to re emboss
    const TextConfiguration &tc = *text_volume.text_configuration;
    const EmbossShape       &es = *text_volume.emboss_shape;
    const ImWchar* ranges = ImGui::GetIO().Fonts->GetGlyphRangesDefault();
 
    StyleManager style_manager(ranges, create_default_styles);
    StyleManager::Style style{tc.style, es.projection};
    if (!style_manager.load_style(style))
        return false; // can't load font
 
    TextLinesModel text_lines;
    const Selection &selection = wxGetApp().plater()->canvas3D()->get_selection();
    DataBasePtr base = create_emboss_data_base(tc.text, style_manager, text_lines, selection, text_volume.type(), job_cancel);
    DataUpdate  data{std::move(base), text_volume.id(), false};
 
    RaycastManager raycast_manager; // Nothing is cached now, so It need to create raycasters
    return start_update_volume(std::move(data), text_volume, selection, raycast_manager);
}

References create_default_styles(), Slic3r::ModelVolume::emboss_shape, Slic3r::ObjectBase::id(), Slic3r::GUI::Emboss::StyleManager::load_style(), Slic3r::EmbossShape::projection, Slic3r::GUI::Emboss::start_update_volume(), Slic3r::TextConfiguration::style, style, Slic3r::TextConfiguration::text, Slic3r::ModelVolume::text_configuration, and Slic3r::ModelVolume::type().

Here is the call graph for this function:

◆ register_grabbers_for_picking()

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

protectedinherited

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

References m_grabbers, and m_group_id.

Referenced by register_raycasters_for_picking().

Here is the caller graph for this function:

◆ register_raycasters_for_picking()

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

inlineinherited

232{ register_grabbers_for_picking(); on_register_raycasters_for_picking(); }

Slic3r::GUI::GLGizmoBase::register_grabbers_for_picking

void register_grabbers_for_picking()

Definition GLGizmoBase.cpp:398

Slic3r::GUI::GLGizmoBase::on_register_raycasters_for_picking

virtual void on_register_raycasters_for_picking()

Definition GLGizmoBase.hpp:267

References on_register_raycasters_for_picking(), and register_grabbers_for_picking().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reinit_text_lines()

void GLGizmoEmboss::reinit_text_lines ( unsigned count_lines = 0 )

private

                                                          {    
    init_text_lines(m_text_lines, m_parent.get_selection(), m_style_manager, count_lines);
}

References Slic3r::GUI::GLGizmoBase::m_parent, m_style_manager, and m_text_lines.

Referenced by draw_advanced(), draw_font_list_line(), draw_text_input(), set_height(), and set_volume_by_selection().

Here is the caller graph for this function:

◆ remove_notification_not_valid_font()

void GLGizmoEmboss::remove_notification_not_valid_font ( )

private

{
    if (!m_is_unknown_font) return;
    m_is_unknown_font      = false;
    auto type                 = NotificationType::UnknownFont;
    auto notification_manager = wxGetApp().plater()->get_notification_manager();
    notification_manager->close_notification_of_type(type);
}

References m_is_unknown_font, and Slic3r::GUI::UnknownFont.

Referenced by create_notification_not_valid_font(), on_set_state(), process(), reset_volume(), and set_volume_by_selection().

Here is the caller graph for this function:

◆ render()

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

inlineinherited

214{ on_render(); }

Slic3r::GUI::GLGizmoBase::on_render

virtual void on_render()=0

References on_render().

Here is the call graph for this function:

◆ render_combo()

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

protectedinherited

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ render_cross_mark()

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

protectedinherited

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ render_follows_cursor()

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

inlinevirtualinherited

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

189{ return false; }

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

Here is the caller graph for this function:

◆ render_grabbers() [1/3]

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

protectedinherited

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ render_grabbers() [2/3]

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

protectedinherited

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

References m_grabbers, and render_grabbers().

Here is the call graph for this function:

◆ render_grabbers() [3/3]

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

protectedinherited

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

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

Here is the call graph for this function:

◆ render_input_window()

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

inherited

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

References m_first_input_window_render, m_parent, and on_render_input_window().

Here is the call graph for this function:

◆ reset_to_default_style()

void GLGizmoEmboss::reset_to_default_style ( )

private

{
    int                        default_index = 0;
    const StyleManager::Style& current_style = m_style_manager.get_style();
    const StyleManager::Style& default_style = m_style_manager.get_styles()[default_index];
 
    StyleManager::Style cur_s = current_style; // copy
    StyleManager::Style new_s = default_style; // copy
 
    if (m_style_manager.load_style(default_index)) {
        ::fix_transformation(cur_s, new_s, m_parent);
        process();
    }
}

References Slic3r::GUI::GLGizmoBase::m_parent, m_style_manager, and process().

Referenced by draw_window().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reset_volume()

void GLGizmoEmboss::reset_volume ( )

private

{
    if (m_volume == nullptr)
        return; // already reseted
 
    m_volume = nullptr;
    m_volume_id.id = 0;
 
    // No more need of current notification
    remove_notification_not_valid_font();
}

References m_volume, m_volume_id, and remove_notification_not_valid_font().

Referenced by on_set_state(), and set_volume_by_selection().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ rev_checkbox()

bool GLGizmoEmboss::rev_checkbox	(	const std::string &	name,
		bool &	value,
		const bool *	default_value,
		const std::string &	undo_tooltip ) const

private

{
    // draw offseted input
    auto draw_offseted_input = [this, &offset = m_gui_cfg->advanced_input_offset, &name, &value](){
        ImGui::SameLine(offset);
        return m_imgui->bbl_checkbox(wxString::FromUTF8("##" + name), value);
    };
    return revertible(name, value, default_value, undo_tooltip,
                      0.0f, draw_offseted_input);
}

References m_gui_cfg, Slic3r::GUI::GLGizmoBase::m_imgui, Slic3r::offset(), and revertible().

Referenced by draw_advanced().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ rev_input()

template<typename T>

bool GLGizmoEmboss::rev_input	(	const std::string &	name,
		T &	value,
		const T *	default_value,
		const std::string &	undo_tooltip,
		T	step,
		T	step_fast,
		const char *	format,
		ImGuiInputTextFlags	flags = 0 ) const

private

Reversible input float with option to restor default value TODO: make more general, static and move to ImGuiWrapper.

Returns: True when value changed otherwise FALSE.

{
    // draw offseted input
    auto draw_offseted_input = [this, &offset = m_gui_cfg->input_offset, &width = m_gui_cfg->input_width,
                                &name, &value, &step, &step_fast, format, flags](){
        ImGui::SameLine(offset);
        ImGui::SetNextItemWidth(width);
        bool changed = imgui_input(("##" + name).c_str(),
            &value, step, step_fast, format, flags);
        m_imgui->request_frames_while_held(); // ORCA auto-repeat of the +/- buttons
        return changed;
    };
    return revertible(name, value, default_value, undo_tooltip, 
                      0.0f, draw_offseted_input);
}

References Slic3r::GUI::GLGizmoBase::format(), imgui_input(), m_gui_cfg, Slic3r::GUI::GLGizmoBase::m_imgui, Slic3r::offset(), and revertible().

Referenced by rev_input_mm().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ rev_input_mm()

template<typename T>

bool GLGizmoEmboss::rev_input_mm	(	const std::string &	name,
		T &	value,
		const T *	default_value,
		const std::string &	undo_tooltip,
		T	step,
		T	step_fast,
		const char *	format,
		bool	use_inch,
		const std::optional< float > &	scale ) const

private

{
    // _variable which temporary keep value
    T value_ = value;
    T default_value_;
    if (use_inch) {
        // calc value in inch
        value_ *= GizmoObjectManipulation::mm_to_in;
        if (default_value_ptr) {
            default_value_    = GizmoObjectManipulation::mm_to_in * (*default_value_ptr);
            default_value_ptr = &default_value_;
        }
    }
    if (scale.has_value())        
        value_ *= *scale;
    bool use_correction = use_inch || scale.has_value();
    if (rev_input(name, use_correction ? value_ : value, default_value_ptr, undo_tooltip, step, step_fast, format)) {
        if (use_correction) {
            value = value_;
            if (use_inch)
                value *= GizmoObjectManipulation::in_to_mm;
            if (scale.has_value())
                value /= *scale;
        }
        return true;
    }
    return false;
}

References Slic3r::GUI::GLGizmoBase::format(), Slic3r::GUI::GizmoObjectManipulation::in_to_mm, Slic3r::GUI::GizmoObjectManipulation::mm_to_in, rev_input(), and scale().

Referenced by draw_depth(), and draw_height().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ rev_slider() [1/3]

bool GLGizmoEmboss::rev_slider	(	const std::string &	name,
		float &	value,
		const float *	default_value,
		const std::string &	undo_tooltip,
		float	v_min,
		float	v_max,
		const std::string &	format,
		const wxString &	tooltip ) const

private

{    
    auto draw_slider_float = [&]() -> bool {
        float slider_offset = m_gui_cfg->advanced_input_offset;
        float slider_width  = m_gui_cfg->input_width;
        ImGui::SameLine(slider_offset);
        ImGui::SetNextItemWidth(slider_width);
        return m_imgui->slider_float("##" + name, &value, v_min, v_max,
            format.c_str(), 1.f, false, tooltip);
    };
    return revertible(name, value, default_value,
        undo_tooltip, 0.0f, draw_slider_float);
}

References Slic3r::GUI::GLGizmoBase::format(), m_gui_cfg, Slic3r::GUI::GLGizmoBase::m_imgui, and revertible().

Here is the call graph for this function:

◆ rev_slider() [2/3]

bool GLGizmoEmboss::rev_slider	(	const std::string &	name,
		std::optional< float > &	value,
		const std::optional< float > *	default_value,
		const std::string &	undo_tooltip,
		float	v_min,
		float	v_max,
		const std::string &	format,
		const wxString &	tooltip ) const

private

{    
    auto draw_slider_optional_float = [&]() -> bool {
        float slider_offset = m_gui_cfg->advanced_input_offset;
        float slider_width  = m_gui_cfg->input_width;
        ImGui::SameLine(slider_offset);
        ImGui::SetNextItemWidth(slider_width);
        return m_imgui->slider_optional_float(("##" + name).c_str(), value,
            v_min, v_max, format.c_str(), 1.f, false, tooltip);
    };
    return revertible(name, value, default_value,
        undo_tooltip, 0.0f, draw_slider_optional_float);
}

References Slic3r::GUI::GLGizmoBase::format(), m_gui_cfg, Slic3r::GUI::GLGizmoBase::m_imgui, and revertible().

Here is the call graph for this function:

◆ rev_slider() [3/3]

bool GLGizmoEmboss::rev_slider	(	const std::string &	name,
		std::optional< int > &	value,
		const std::optional< int > *	default_value,
		const std::string &	undo_tooltip,
		int	v_min,
		int	v_max,
		const std::string &	format,
		const wxString &	tooltip ) const

private

{    
    auto draw_slider_optional_int = [&]() -> bool {
        float slider_offset = m_gui_cfg->advanced_input_offset;
        float slider_width  = m_gui_cfg->input_width;
        ImGui::SameLine(slider_offset);
        ImGui::SetNextItemWidth(slider_width);
        return m_imgui->slider_optional_int( ("##" + name).c_str(), value, 
            v_min, v_max, format.c_str(), 1.f, false, tooltip);
    };
    return revertible(name, value, default_value,
        undo_tooltip, 0.0f, draw_slider_optional_int);
}

References Slic3r::GUI::GLGizmoBase::format(), m_gui_cfg, Slic3r::GUI::GLGizmoBase::m_imgui, and revertible().

Referenced by draw_advanced().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ revertible()

template<typename T, typename Draw>

bool GLGizmoEmboss::revertible	(	const std::string &	name,
		T &	value,
		const T *	default_value,
		const std::string &	undo_tooltip,
		float	undo_offset,
		Draw	draw ) const

private

{
    ImGui::AlignTextToFramePadding();
    bool changed_from_default = exist_change(value, default_value);
    if (changed_from_default || default_value == nullptr)
        ImGuiWrapper::text_colored(ImGuiWrapper::COL_MODIFIED, name); // ORCA Match color
    else
        ImGuiWrapper::text(name);
 
    bool changed = draw();
 
    if (changed_from_default == false) {
        ImGui::PushStyleVar(ImGuiStyleVar_Alpha, 0.0f);
        m_imgui->disabled_begin(true);
    }
 
    // render revert changes button
    auto r_icon = get_icon(m_icons, IconType::undo, IconState::hovered);
    ImGuiWindow *window = ImGui::GetCurrentWindow();
    float prev_x = window->DC.CursorPosPrevLine.x;
    ImGui::SameLine(undo_offset); // change cursor postion
    if (Slic3r::GUI::button(r_icon, r_icon, r_icon)) { // ORCA draw bottom with same orange color
        value = *default_value;
 
        // !! Fix to detect change of value after revert of float-slider
        m_imgui->get_last_slider_status().deactivated_after_edit = true;
 
        return true;
    } else if (ImGui::IsItemHovered()) 
        m_imgui->tooltip(undo_tooltip, m_gui_cfg->max_tooltip_width);
 
    if (undo_offset != 0.0f)
        window->DC.CursorPosPrevLine.x = prev_x; // set back previous position
 
    if (changed_from_default == false) {
        ImGui::PopStyleVar();
        m_imgui->disabled_end();
    }
 
    return changed;
}

References Slic3r::GUI::button(), Slic3r::GUI::ImGuiWrapper::COL_MODIFIED, Slic3r::GUI::draw(), exist_change(), anonymous_namespace{GLGizmoEmboss.cpp}::hovered, m_gui_cfg, m_icons, Slic3r::GUI::GLGizmoBase::m_imgui, Slic3r::GUI::ImGuiWrapper::text(), Slic3r::GUI::ImGuiWrapper::text_colored(), and anonymous_namespace{GLGizmoEmboss.cpp}::undo.

Referenced by draw_advanced(), rev_checkbox(), rev_input(), rev_slider(), rev_slider(), and rev_slider().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ save()

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

inlineinherited

171{ on_save(ar); }

Slic3r::GUI::GLGizmoBase::on_save

virtual void on_save(cereal::BinaryOutputArchive &ar) const

Definition GLGizmoBase.hpp:242

References on_save().

Here is the call graph for this function:

◆ select_facename()

bool GLGizmoEmboss::select_facename ( const wxString & facename )

private

{
    if (!wxFontEnumerator::IsValidFacename(facename)) return false;
    // Select font
    wxFont wx_font(wxFontInfo().FaceName(facename).Encoding(Facenames::encoding));
    if (!wx_font.IsOk()) return false;
#ifdef USE_PIXEL_SIZE_IN_WX_FONT
    // wx font could change source file by size of font
    int point_size = static_cast<int>(m_style_manager.get_font_prop().size_in_mm);
    wx_font.SetPointSize(point_size);
#endif // USE_PIXEL_SIZE_IN_WX_FONT
    if (!m_style_manager.set_wx_font(wx_font)) return false;
    process();
    return true;
}

References anonymous_namespace{GLGizmoEmboss.cpp}::Facenames::encoding, m_style_manager, and process().

Referenced by draw_font_list().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_common_data_pool()

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

inlineinherited

193{ m_c = ptr; }

Slic3r::GUI::GLGizmoBase::m_c

CommonGizmosDataPool * m_c

Definition GLGizmoBase.hpp:155

References m_c.

◆ set_dirty()

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

protectedinherited

                            {
    m_dirty = true;
}

References m_dirty.

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

Here is the caller graph for this function:

◆ set_height()

bool GLGizmoEmboss::set_height ( )

private

                               {
    float &value = m_style_manager.get_font_prop().size_in_mm;
 
    // size can't be zero or negative
    apply(value, limits.size_in_mm);
 
    if (m_volume == nullptr || !m_volume->text_configuration.has_value()) {
        assert(false);
        return false;
    }
    
    // only different value need process
    if (is_approx(value, m_volume->text_configuration->style.prop.size_in_mm))
        return false;
    
    if (m_style_manager.get_font_prop().per_glyph)
        reinit_text_lines(m_text_lines.get_lines().size());
 
#ifdef USE_PIXEL_SIZE_IN_WX_FONT
    // store font size into path serialization
    const wxFont &wx_font = m_style_manager.get_wx_font();
    if (wx_font.IsOk()) {
        wxFont wx_font_new = wx_font; // copy
        wx_font_new.SetPointSize(static_cast<int>(value));
        m_style_manager.set_wx_font(wx_font_new);
    }
#endif
    return true;
}

References Slic3r::apply(), Slic3r::is_approx(), m_style_manager, m_text_lines, m_volume, and reinit_text_lines().

Referenced by draw_height().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_hover_id()

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

inherited

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

References m_dragging, m_hover_id, and on_set_hover_id().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_icon_filename()

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

inherited

                                                             {
    m_icon_filename = filename;
}

References m_icon_filename.

◆ set_state()

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

inlineinherited

176{ m_state = state; on_set_state(); }

Slic3r::GUI::GLGizmoBase::on_set_state

virtual void on_set_state()

Definition GLGizmoBase.hpp:244

References m_state, and on_set_state().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_volume_by_selection()

void GLGizmoEmboss::set_volume_by_selection ( )

private

{
    const Selection &selection = m_parent.get_selection();
    const GLVolume  *gl_volume = get_selected_gl_volume(selection);
    if (gl_volume == nullptr)
        return reset_volume();
 
    const ModelObjectPtrs &objects = m_parent.get_model()->objects;
    ModelVolume *volume = get_model_volume(*gl_volume, objects);
    if (volume == nullptr)
        return reset_volume();
 
    // is same volume as actual selected?
    if (volume->id() == m_volume_id && 
        m_volume != nullptr && 
        volume->text_configuration->style == m_volume->text_configuration->style)
        return;
 
    // for changed volume notification is NOT valid
    remove_notification_not_valid_font();
 
    // Do not use focused input value when switch volume(it must swith value)
    if (m_volume != nullptr && m_volume != volume) // when update volume it changed id BUT not pointer
        ImGuiWrapper::left_inputs();
 
    // Is selected volume text volume?
    const std::optional<TextConfiguration> &tc_opt = volume->text_configuration;
    if (!tc_opt.has_value())
        return reset_volume();
 
    // Emboss shape must be setted
    assert(volume->emboss_shape.has_value());
    if (!volume->emboss_shape.has_value())
        return;
 
    const TextConfiguration &tc = *tc_opt;
    const EmbossStyle    &style = tc.style;
 
    std::optional<wxString> installed_name = get_installed_face_name(style.prop.face_name, *m_face_names);
 
    wxFont wx_font;
    // load wxFont from same OS when font name is installed
    if (style.type == WxFontUtils::get_current_type() && installed_name.has_value())
        wx_font = WxFontUtils::load_wxFont(style.path);
 
    // Flag that is selected same font
    bool is_exact_font = true;
    // Different OS or try found on same OS
    if (!wx_font.IsOk()) {
        is_exact_font = false;
        // Try create similar wx font by FontFamily
        wx_font = WxFontUtils::create_wxFont(style);
        if (installed_name.has_value() && !installed_name->empty())
            is_exact_font = wx_font.SetFaceName(*installed_name);
 
        // Have to use some wxFont
        if (!wx_font.IsOk())
            wx_font = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);
    }
    assert(wx_font.IsOk());
 
    // Load style to style manager
    const auto &styles = m_style_manager.get_styles();
    auto has_same_name = [&name = style.name](const StyleManager::Style &style_item) { return style_item.name == name; };
 
    StyleManager::Style style_{style};  // copy  
    style_.projection = volume->emboss_shape->projection;
    style_.angle = calc_angle(selection);
    style_.distance = calc_distance(*gl_volume, m_raycast_manager, m_parent);
        
    if (auto it = std::find_if(styles.begin(), styles.end(), has_same_name);
        it == styles.end()) {
        // style was not found
        m_style_manager.load_style(style_, wx_font);
    } else {
        // style name is in styles list
        size_t style_index = it - styles.begin();
        if (!m_style_manager.load_style(style_index)) {
            // can`t load stored style
            m_style_manager.erase(style_index);
            m_style_manager.load_style(style_, wx_font);
        } else {
            // stored style is loaded, now set modification of style
            m_style_manager.get_style() = style_;
            m_style_manager.set_wx_font(wx_font);
        }
    }
    
    if (!is_exact_font)
        create_notification_not_valid_font(tc);
 
    // cancel previous job
    if (m_job_cancel != nullptr) {
        m_job_cancel->store(true);
        m_job_cancel = nullptr;
    }
 
    m_text   = tc.text;
    m_volume = volume;
    m_volume_id = volume->id();
        
    if (tc.style.prop.per_glyph)
        reinit_text_lines();
 
    // Calculate current angle of up vector
    assert(m_style_manager.is_active_font());
    if (m_style_manager.is_active_font()) 
        m_style_manager.get_style().angle = calc_angle(selection);
 
    // calculate scale for height and depth inside of scaled object instance
    calculate_scale();    
}

References Slic3r::GUI::Emboss::StyleManager::Style::angle, Slic3r::GUI::calc_angle(), Slic3r::GUI::calc_distance(), calculate_scale(), create_notification_not_valid_font(), Slic3r::GUI::WxFontUtils::create_wxFont(), Slic3r::GUI::Emboss::StyleManager::Style::distance, Slic3r::ModelVolume::emboss_shape, Slic3r::GUI::WxFontUtils::get_current_type(), Slic3r::GUI::get_model_volume(), Slic3r::GUI::get_selected_gl_volume(), Slic3r::ObjectBase::id(), Slic3r::GUI::ImGuiWrapper::left_inputs(), Slic3r::GUI::WxFontUtils::load_wxFont(), m_face_names, m_job_cancel, Slic3r::GUI::GLGizmoBase::m_parent, m_raycast_manager, m_style_manager, m_text, m_volume, m_volume_id, Slic3r::FontProp::per_glyph, Slic3r::GUI::Emboss::StyleManager::Style::projection, Slic3r::EmbossStyle::prop, reinit_text_lines(), remove_notification_not_valid_font(), reset_volume(), Slic3r::TextConfiguration::style, style, Slic3r::TextConfiguration::text, and Slic3r::ModelVolume::text_configuration.

Referenced by data_changed(), and on_shortcut_key().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ shortcut()

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

inlineinherited

178{ return m_shortcut; }

References m_shortcut.

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

Here is the caller graph for this function:

◆ unregister_grabbers_for_picking()

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

protectedinherited

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

References m_grabbers.

Referenced by unregister_raycasters_for_picking().

Here is the caller graph for this function:

◆ unregister_raycasters_for_picking()

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

inlineinherited

233{ unregister_grabbers_for_picking(); on_unregister_raycasters_for_picking(); }

Slic3r::GUI::GLGizmoBase::on_unregister_raycasters_for_picking

virtual void on_unregister_raycasters_for_picking()

Definition GLGizmoBase.hpp:268

Slic3r::GUI::GLGizmoBase::unregister_grabbers_for_picking

void unregister_grabbers_for_picking()

Definition GLGizmoBase.cpp:405

References on_unregister_raycasters_for_picking(), and unregister_grabbers_for_picking().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_items_state()

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

inherited

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

References m_dirty.

◆ update_render_colors()

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

staticinherited

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ use_grabbers()

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

protectedinherited

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

Parameters

mouse_event Keep information about mouse click

Returns: same as on_mouse

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ volume_transformation_changed()

void GLGizmoEmboss::volume_transformation_changed ( )

private

{
    if (m_volume == nullptr || 
        !m_volume->text_configuration.has_value() ||
        !m_volume->emboss_shape.has_value() ||
        !m_style_manager.is_active_font()) {
        assert(false);
        return;
    }
 
    if (!m_keep_up) {
        // Re-Calculate current angle of up vector
        m_style_manager.get_style().angle = calc_angle(m_parent.get_selection());
    } else {
        // angle should be the same
        assert(is_approx(m_style_manager.get_style().angle, calc_angle(m_parent.get_selection())));
    }
 
    const TextConfiguration &tc = *m_volume->text_configuration;
    const EmbossShape &es = *m_volume->emboss_shape;
 
    bool per_glyph = tc.style.prop.per_glyph;
    if (per_glyph)
        init_text_lines(m_text_lines, m_parent.get_selection(), m_style_manager, m_text_lines.get_lines().size());
 
    bool use_surface = es.projection.use_surface;
 
    // Update surface by new position
    if (use_surface || per_glyph)
        process();
    else {
        // inform slicing process that model changed
        // SLA supports, processing
        // ensure on bed
        wxGetApp().plater()->changed_object(*m_volume->get_object());
    }
 
    // Show correct value of height & depth inside of inputs
    calculate_scale();
}

References Slic3r::GUI::calc_angle(), calculate_scale(), Slic3r::is_approx(), m_keep_up, Slic3r::GUI::GLGizmoBase::m_parent, m_style_manager, m_text_lines, m_volume, Slic3r::FontProp::per_glyph, process(), Slic3r::EmbossShape::projection, Slic3r::EmbossStyle::prop, Slic3r::TextConfiguration::style, and Slic3r::EmbossProjection::use_surface.

Referenced by draw_advanced(), on_mouse_for_translate(), and on_stop_dragging().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ volume_transformation_changing()

void GLGizmoEmboss::volume_transformation_changing ( )

private

{
    if (m_volume == nullptr || !m_volume->text_configuration.has_value()) {
        assert(false);
        return;
    }
    const FontProp &prop = m_volume->text_configuration->style.prop;
    if (prop.per_glyph)
        init_text_lines(m_text_lines, m_parent.get_selection(), m_style_manager, m_text_lines.get_lines().size());
}

References Slic3r::GUI::GLGizmoBase::m_parent, m_style_manager, m_text_lines, m_volume, and Slic3r::FontProp::per_glyph.

Referenced by on_mouse_for_translate().

Here is the caller graph for this function:

◆ wants_enter_leave_snapshots()

bool GLGizmoEmboss::wants_enter_leave_snapshots ( ) const

overrideprotectedvirtual

Reimplemented from Slic3r::GUI::GLGizmoBase.

804{ return true; }

Member Data Documentation

◆ AXES_COLOR

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

staticinherited

Initial value:

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

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

◆ AXES_HOVER_COLOR

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

staticinherited

Initial value:

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

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

◆ BASE_ID

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

staticinherited

◆ CONSTRAINED_COLOR

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

staticinherited

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

◆ count

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

privateinherited

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

◆ DEFAULT_BASE_COLOR

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

staticinherited

◆ DEFAULT_DRAG_COLOR

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

staticinherited

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

◆ DEFAULT_HIGHLIGHT_COLOR

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

staticinherited

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

◆ FLATTEN_COLOR

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

staticinherited

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

◆ FLATTEN_HOVER_COLOR

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

staticinherited

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

◆ GRABBER_ELEMENTS_MAX_COUNT

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

staticinherited

◆ GRABBER_HOVER_COL

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

staticinherited

◆ GRABBER_NORMAL_COL

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

staticinherited

◆ GRABBER_UNIFORM_COL

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

staticinherited

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

◆ GRABBER_UNIFORM_HOVER_COL

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

staticinherited

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

◆ INV_ZOOM

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

staticinherited

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

◆ last_input_window_width

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

protectedinherited

Referenced by GizmoImguiEnd(), and GizmoImguiSetNextWIndowPos().

◆ m_c

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

protectedinherited

155{ nullptr };

◆ m_dirty

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

privateinherited

293{ false };

Referenced by set_dirty(), and update_items_state().

◆ m_dragging

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

protectedinherited

151{ false };

◆ m_face_names

std::unique_ptr<Facenames> Slic3r::GUI::GLGizmoEmboss::m_face_names

private

Referenced by GLGizmoEmboss(), draw_font_list(), init_font_name_texture(), and set_volume_by_selection().

◆ m_first_input_window_render

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

protectedinherited

154{ true };

Referenced by render_input_window().

◆ m_grabbers

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

mutableprotectedinherited

◆ m_group_id

int Slic3r::GUI::GLGizmoBase::m_group_id

protectedinherited

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

◆ m_gui_cfg

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

private

◆ m_hover_id

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

protectedinherited

150{ -1 };

◆ M_ICON_FILENAME

const std::string Slic3r::GUI::GLGizmoEmboss::M_ICON_FILENAME

staticprivate

◆ m_icon_filename

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

protectedinherited

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

◆ m_icon_manager

IconManager Slic3r::GUI::GLGizmoEmboss::m_icon_manager

private

Referenced by init_icons().

◆ m_icons

IconManager::VIcons Slic3r::GUI::GLGizmoEmboss::m_icons

private

Referenced by draw_advanced(), draw_bold_button(), draw_delete_style_button(), draw_font_list_line(), draw_italic_button(), draw_style_add_button(), draw_style_rename_button(), draw_style_save_button(), draw_text_input(), init_icons(), and revertible().

◆ m_imgui

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

protectedinherited

◆ m_is_advanced_edit_style

bool Slic3r::GUI::GLGizmoEmboss::m_is_advanced_edit_style = false

private

Referenced by draw_window().

◆ m_is_dark_mode

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

protectedinherited

◆ m_is_unknown_font

bool Slic3r::GUI::GLGizmoEmboss::m_is_unknown_font = false

private

Referenced by create_notification_not_valid_font(), draw_font_list_line(), draw_window(), on_render_input_window(), and remove_notification_not_valid_font().

◆ m_job_cancel

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

private

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

◆ m_keep_up

bool Slic3r::GUI::GLGizmoEmboss::m_keep_up = true

private

Referenced by draw_advanced(), on_mouse_for_translate(), and volume_transformation_changed().

◆ m_parent

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

protectedinherited

◆ m_raycast_manager

RaycastManager Slic3r::GUI::GLGizmoEmboss::m_raycast_manager

private

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

◆ m_rotate_gizmo

GLGizmoRotate Slic3r::GUI::GLGizmoEmboss::m_rotate_gizmo

private

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

◆ m_rotate_start_angle

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

private

Referenced by on_mouse_for_rotation(), and on_stop_dragging().

◆ m_scale_depth

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

private

Referenced by calculate_scale(), and draw_depth().

◆ m_scale_height

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

private

Referenced by calculate_scale(), draw_height(), and draw_text_input().

◆ m_shortcut

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

protectedinherited

◆ m_shortcuts

std::vector<std::pair<wxString, wxString> > Slic3r::GUI::GLGizmoEmboss::m_shortcuts

private

Referenced by draw_window(), and on_init().

◆ m_sprite_id

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

protectedinherited

Referenced by GLGizmoBase(), and get_sprite_id().

◆ m_state

EState Slic3r::GUI::GLGizmoBase::m_state

protectedinherited

◆ m_style_manager

Emboss::StyleManager Slic3r::GUI::GLGizmoEmboss::m_style_manager

private

◆ m_surface_drag

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

private

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

◆ m_text

std::string Slic3r::GUI::GLGizmoEmboss::m_text

private

Referenced by close(), create_volume(), create_volume(), draw_font_list(), draw_style_list(), draw_text_input(), init_create(), process(), and set_volume_by_selection().

◆ m_text_contain_unknown_glyph

bool Slic3r::GUI::GLGizmoEmboss::m_text_contain_unknown_glyph = false

private

Referenced by draw_text_input().

◆ m_text_lines

TextLinesModel Slic3r::GUI::GLGizmoEmboss::m_text_lines

private

Referenced by create_volume(), create_volume(), do_mirror(), draw_advanced(), draw_font_list_line(), draw_text_input(), on_render(), process(), reinit_text_lines(), set_height(), volume_transformation_changed(), and volume_transformation_changing().

◆ m_volume

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

private

◆ m_volume_id

ObjectID Slic3r::GUI::GLGizmoEmboss::m_volume_id

private

Referenced by on_mouse(), on_render(), on_render_input_window(), reset_volume(), and set_volume_by_selection().

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

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

Classes

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Protected Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Enumeration Documentation

◆ EGrabberExtension

◆ EState

Constructor & Destructor Documentation

◆ GLGizmoEmboss()

Member Function Documentation

◆ apply_clipping_plane()

◆ calculate_scale()

◆ close()

◆ create_default_styles()

◆ create_notification_not_valid_font() [1/2]

◆ create_notification_not_valid_font() [2/2]

◆ create_volume() [1/2]

◆ create_volume() [2/2]

◆ data_changed()

◆ do_mirror()

◆ do_stop_dragging()

◆ draw_advanced()

◆ draw_bold_button()

◆ draw_delete_style_button()

◆ draw_depth()

◆ draw_font_list()

◆ draw_font_list_line()

◆ draw_height()

◆ draw_italic_button()

◆ draw_model_type()

◆ draw_style_add_button()

◆ draw_style_list()

◆ draw_style_rename_button()

◆ draw_style_rename_popup()

◆ draw_style_save_as_popup()

◆ draw_style_save_button()

◆ draw_text_input()

◆ draw_window()

◆ format()

◆ get_action_snapshot_name()

◆ get_count()

◆ get_gizmo_entering_text()

◆ get_gizmo_leaving_text()

◆ get_gizmo_name()

◆ get_hover_id()

◆ get_icon_filename()

◆ get_name()

◆ get_requirements()

◆ get_sprite_id()

◆ get_state()

◆ get_tooltip()

◆ GizmoImguiBegin()

◆ GizmoImguiEnd()

◆ GizmoImguiSetNextWIndowPos() [1/2]

◆ GizmoImguiSetNextWIndowPos() [2/2]

◆ init()

◆ init_create()

◆ init_font_name_texture()

◆ init_icons()

◆ is_activable()

◆ is_changed_from_default_style()

◆ is_dragging()

◆ is_in_editing_mode()

◆ is_selectable()

◆ is_selection_rectangle_dragging()

◆ load()

◆ load_render_colors()

◆ on_change_color_mode()

◆ on_disable_grabber()

◆ on_dragging()

◆ on_enable_grabber()

◆ on_get_name()