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

Collaboration diagram for Slic3r::GUI::ImGuiWrapper:

Classes
struct	LastSliderStatus

Public Member Functions
	ImGuiWrapper ()
	~ImGuiWrapper ()
void	read_glsl_version ()
void	set_language (const std::string &language)
void	set_display_size (float w, float h)
void	set_scaling (float font_size, float scale_style, float scale_both)
bool	update_mouse_data (wxMouseEvent &evt)
bool	update_key_data (wxKeyEvent &evt)
float	get_font_size () const
float	get_style_scaling () const
const ImWchar *	get_glyph_ranges () const
void	new_frame ()
ImDrawData *	end_frame ()
void	render (ImDrawData *draw_data)
float	scaled (float x) const
ImVec2	scaled (float x, float y) const
ImVec2	calc_button_size (const wxString &text, const ImVec2 &button_size=ImVec2(0, 0)) const
float	find_widest_text (std::vector< wxString > &text_list)
ImVec2	get_item_spacing () const
float	get_slider_float_height () const
const LastSliderStatus &	get_last_slider_status () const
LastSliderStatus &	get_last_slider_status ()
void	set_next_window_pos (float x, float y, int flag, float pivot_x=0.0f, float pivot_y=0.0f)
void	set_next_window_bg_alpha (float alpha)
void	set_next_window_size (float x, float y, ImGuiCond cond)
bool	bbl_combo_with_filter (const char label, const std::string &preview_value, const std::vector< std::string > &all_items, std::vector< int > filtered_items_idx, bool *is_filtered, float item_height=0.0f)
bool	bbl_input_double (const wxString &label, const double &value, const std::string &format="%0.2f")
bool	bbl_slider_float (const std::string &label, float v, float v_min, float v_max, const char format="%.3f", float power=1.0f, bool clamp=true, const wxString &tooltip={})
bool	bbl_slider_float_style (const std::string &label, float v, float v_min, float v_max, const char format="%.3f", float power=1.0f, bool clamp=true, const wxString &tooltip={})
bool	begin (const std::string &name, int flags=0)
bool	begin (const wxString &name, int flags=0)
bool	begin (const std::string &name, bool *close, int flags=0)
bool	begin (const wxString &name, bool *close, int flags=0)
void	end ()
bool	button (const wxString &label, const wxString &tooltip={})
bool	bbl_button (const wxString &label, const wxString &tooltip={})
bool	button (const wxString &label, float width, float height)
bool	button (const wxString &label, const ImVec2 &size, bool enable)
bool	glyph_button (wchar_t icon_char, ImVec2 icon_size)
bool	radio_button (const wxString &label, bool active)
bool	input_double (const std::string &label, const double &value, const std::string &format="%.3f")
bool	input_double (const wxString &label, const double &value, const std::string &format="%.3f")
bool	input_vec3 (const std::string &label, const Vec3d &value, float width, const std::string &format="%.3f")
bool	checkbox (const wxString &label, bool &value)
bool	bbl_checkbox (const wxString &label, bool &value)
bool	bbl_radio_button (const char *label, bool active)
bool	bbl_sliderin (const char label, int v, int v_min, int v_max, const char *format="%d", ImGuiSliderFlags flags=0)
void	warning_text (const char *all_text)
void	warning_text (const wxString &all_text)
void	text_wrapped (const char *label, float wrap_width)
void	text_wrapped (const std::string &label, float wrap_width)
void	text_wrapped (const wxString &label, float wrap_width)
void	tooltip (const char *label, float wrap_width)
void	tooltip (const std::string &label, float wrap_width)
void	tooltip (const wxString &label, float wrap_width)
void	filament_group (const std::string &filament_type, const char *hex_color, unsigned char filament_id, float align_width)
std::tuple< ImVec2, bool >	calculate_filament_group_text_size (const std::string &filament_type)
void	sub_title (const std::string &label)
bool	slider_float (const char label, float v, float v_min, float v_max, const char *format="%.3f", float power=1.0f, bool clamp=true)
bool	slider_float (const std::string &label, float v, float v_min, float v_max, const char format="%.3f", float power=1.0f, bool clamp=true)
bool	slider_float (const wxString &label, float v, float v_min, float v_max, const char format="%.3f", float power=1.0f, bool clamp=true)
bool	image_button (ImTextureID user_texture_id, const ImVec2 &size, const ImVec2 &uv0=ImVec2(0.0, 0.0), const ImVec2 &uv1=ImVec2(1.0, 1.0), int frame_padding=-1, const ImVec4 &bg_col=ImVec4(0.0, 0.0, 0.0, 0.0), const ImVec4 &tint_col=ImVec4(1.0, 1.0, 1.0, 1.0), ImGuiButtonFlags flags=0)
bool	image_button (const wchar_t icon, const wxString &tooltip=L"")
bool	combo (const std::string &label, const std::vector< std::string > &options, int &selection, ImGuiComboFlags flags=0, float label_width=0.0f, float item_width=0.0f)
bool	combo (const wxString &label, const std::vector< std::string > &options, int &selection, ImGuiComboFlags flags=0, float label_width=0.0f, float item_width=0.0f)
bool	undo_redo_list (const ImVec2 &size, const bool is_undo, bool(items_getter)(const bool, int, const char *), int &hovered, int &selected, int &mouse_wheel)
void	search_list (const ImVec2 &size, bool(items_getter)(int, const char label, const char tooltip), char search_str, Search::OptionViewParameters &view_params, int &selected, bool &edited, int &mouse_wheel, bool is_localized)
void	bold_text (const std::string &str)
void	title (const std::string &str)
void	title (const std::string &str, bool suppress_seperator)
const std::vector< std::string >	get_fonts_names () const
bool	push_bold_font ()
bool	pop_bold_font ()
bool	push_font_by_name (std::string font_name)
bool	pop_font_by_name (std::string font_name)
void	load_fonts_texture ()
void	destroy_fonts_texture ()
void	disabled_begin (bool disabled)
void	disabled_end ()
bool	want_mouse () const
bool	want_keyboard () const
bool	want_text_input () const
bool	want_any_input () const
bool	text_input_active () const
bool	modal_popup_open () const
bool	popup_open () const
void	close_top_popup ()
bool	owns_key (const KeyChord &chord) const
bool	item_held () const
bool	owns_keyboard () const
bool	claim_key_event (const wxKeyEvent &evt)
void	forget_key_claims ()
bool	slider_optional_float (const char label, std::optional< float > &v, float v_min, float v_max, const char format="%.3f", float power=1.0f, bool clamp=true, const wxString &tooltip={}, bool show_edit_btn=true, float def_val=.0f)
bool	slider_optional_int (const char label, std::optional< int > &v, int v_min, int v_max, const char format="%.3f", float power=1.0f, bool clamp=true, const wxString &tooltip={}, bool show_edit_btn=true, int def_val=0)
bool	requires_extra_frame () const
void	set_requires_extra_frame ()
void	reset_requires_extra_frame ()
void	request_frames_while_held ()
void	disable_background_fadeout_animation ()
ImFontAtlasCustomRect *	GetTextureCustomRect (const wchar_t &tex_id)
bool	display_initialized () const

Static Public Member Functions
static ImGuiID	draw_data_signature (const ImDrawData *draw_data)
static ImVec2	calc_text_size (std::string_view text, bool hide_text_after_double_hash=false, float wrap_width=-1.0f)
	Extend ImGui::CalcTextSize to use string_view.
static ImVec2	calc_text_size (const std::string &text, bool hide_text_after_double_hash=false, float wrap_width=-1.0f)
static ImVec2	calc_text_size (const wxString &text, bool hide_text_after_double_hash=false, float wrap_width=-1.0f)
static ImVec4	to_ImVec4 (const ColorRGB &color)
static void	text (const char *label)
static void	text (const std::string &label)
static void	text (const wxString &label)
static void	text_colored (const ImVec4 &color, const char *label)
static void	text_colored (const ImVec4 &color, const std::string &label)
static void	text_colored (const ImVec4 &color, const wxString &label)
static bool	input_optional_int (const char *label, std::optional< int > &v, int step=1, int step_fast=100, ImGuiInputTextFlags flags=0, int def_val=0)
static bool	input_optional_float (const char label, std::optional< float > &v, float step=0.0f, float step_fast=0.0f, const char format="%.3f", ImGuiInputTextFlags flags=0, float def_val=.0f)
static bool	drag_optional_float (const char label, std::optional< float > &v, float v_speed, float v_min, float v_max, const char format, float power, float def_val=.0f)
static std::optional< ImVec2 >	change_window_position (const char *window_name, bool try_to_fix)
	Change position of imgui window.
static void	left_inputs ()
	Use ImGui internals to unactivate (lose focus) in input. When input is activ it can't change value by application.
static std::string	trunc (const std::string &text, float width, const char *tail=" ..")
	Truncate text by ImGui draw function to specific width NOTE 1: ImGui must be initialized NOTE 2: Calculation for actual acive imgui font.
static void	escape_double_hash (std::string &text)
	Escape ## in data by add space between hashes Needed when user written text is visualized by ImGui.
static ImVec2	suggest_location (const ImVec2 &dialog_size, const Slic3r::Polygon &interest, const ImVec2 &canvas_size)
	Suggest loacation of dialog window, dependent on actual visible thing on platter like Gizmo menu size, notifications, ... To be near of polygon interest and not over it. And also not out of visible area.
static void	draw (const Polygon &polygon, ImDrawList *draw_list=ImGui::GetOverlayDrawList(), ImU32 color=ImGui::GetColorU32(COL_ORANGE_LIGHT), float thickness=3.f)
	Visualization of polygon.
static void	draw_cross_hair (const ImVec2 &position, float radius=16.f, ImU32 color=ImGui::GetColorU32(ImVec4(1.f, 1.f, 1.f,.75f)), int num_segments=0, float thickness=4.f)
	Draw symbol of cross hair.
static void	draw_gradient_ramp (ImDrawList *draw_list, const ImVec2 &top_left, const ImVec2 &bottom_right, const std::vector< wxColour > &ramp)
	Fill a rect with a filament gradient ramp, one band per pixel row, ramp.front() along the bottom edge. Bands rather than one interpolated rect, because the ramp follows the slot's gradient curve and ImGui's corner interpolation could only draw a straight fade.
static bool	contain_all_glyphs (const ImFont *font, const std::string &text)
	Check that font ranges contain all chars in string (rendered Unicodes are stored in GlyphRanges).
static bool	is_chars_in_ranges (const ImWchar ranges, const char chars_ptr)
static bool	is_char_in_ranges (const ImWchar *ranges, unsigned int letter)
static ImU32	to_ImU32 (const ColorRGBA &color)
static ImVec4	to_ImVec4 (const ColorRGBA &color)
static ColorRGBA	from_ImU32 (const ImU32 &color)
static ColorRGBA	from_ImVec4 (const ImVec4 &color)
static void	on_change_color_mode (bool is_dark)
static void	push_toolbar_style (const float scale)
static void	pop_toolbar_style ()
static void	push_menu_style (const float scale)
static void	pop_menu_style ()
static void	push_common_window_style (const float scale)
static void	pop_common_window_style ()
static void	push_confirm_button_style ()
static void	pop_confirm_button_style ()
static void	push_cancel_button_style ()
static void	pop_cancel_button_style ()
static void	push_button_disable_style ()
static void	pop_button_disable_style ()
static void	push_combo_style (const float scale)
static void	pop_combo_style ()
static void	push_radio_style (const float scale)
static void	pop_radio_style ()

Static Public Attributes
static const ImVec4	COL_GREY_DARK = { 0.333f, 0.333f, 0.333f, 1.0f }
static const ImVec4	COL_GREY_LIGHT = { 0.4f, 0.4f, 0.4f, 1.0f }
static const ImVec4	COL_ORANGE_DARK = { 0.757f, 0.404f, 0.216f, 1.0f }
static const ImVec4	COL_ORANGE_LIGHT = to_ImVec4(ColorRGBA::ORANGE())
static const ImVec4	COL_WINDOW_BACKGROUND = { 0.1f, 0.1f, 0.1f, 0.8f }
static const ImVec4	COL_BUTTON_BACKGROUND = COL_ORANGE_DARK
static const ImVec4	COL_BUTTON_HOVERED = COL_ORANGE_LIGHT
static const ImVec4	COL_BUTTON_ACTIVE = COL_BUTTON_HOVERED
static const ImVec4	COL_RED = ImVec4(1.0f, 0.0f, 0.0f, 1.0f)
static const ImVec4	COL_GREEN = ImVec4(0.0f, 1.0f, 0.0f, 1.0f)
static const ImVec4	COL_BLUE = ImVec4(0.0f, 0.0f, 1.0f, 1.0f)
static const ImVec4	COL_BLUE_LIGHT = ImVec4(0.122f, 0.557f, 0.918f, 1.0f)
static const ImVec4	COL_GREEN_LIGHT = { 0.f, 156 / 255.f, 136 / 255.f, 0.25f }
static const ImVec4	COL_HOVER = { 0.933f, 0.933f, 0.933f, 1.0f }
static const ImVec4	COL_ACTIVE = { 0.675f, 0.675f, 0.675f, 1.0f }
static const ImVec4	COL_TITLE_BG = { 0.745f, 0.745f, 0.745f, 1.0f }
static const ImVec4	COL_WINDOW_BG = { 1.000f, 1.000f, 1.000f, 1.0f }
static const ImVec4	COL_WINDOW_BG_DARK = { 45 / 255.f, 45 / 255.f, 49 / 255.f, 1.f }
static const ImVec4	COL_TOOLBAR_BG = { 250 / 255.f, 250 / 255.f, 250 / 255.f, 1.f }
static const ImVec4	COL_TOOLBAR_BG_DARK = { 57 / 255.f, 60 / 255.f, 66 / 255.f, 1.f }
static const ImVec4	COL_SEPARATOR = { 0.93f, 0.93f, 0.93f, 1.0f }
static const ImVec4	COL_SEPARATOR_DARK = { 0.24f, 0.24f, 0.27f, 1.0f }
static const ImVec4	COL_ORCA = to_ImVec4(ColorRGBA::ORCA())
static const ImVec4	COL_ORCA_DARK = { 0.f , 103 / 255.f, 91 / 255.f, 1.f }
static const ImVec4	COL_ORCA_HOVER = { 38 / 255.f, 166 / 255.f, 154 / 255.f, 1.f }
static const ImVec4	COL_ORCA_HOVER_DARK = { 0.f , 129 / 255.f, 114 / 255.f, 1.f }
static const ImVec4	COL_MODIFIED = { 253.f / 255.f, 111.f / 255.f, 40.f / 255.f, 1}
static const ImVec4	COL_WARNING = to_ImVec4(ColorRGB::WARNING())
static int	TOOLBAR_WINDOW_FLAGS

Private Member Functions
void	init_font (bool compress)
void	init_input ()
void	init_style ()
void	render_draw_data (ImDrawData *draw_data)
void	destroy_font ()
std::vector< unsigned char >	load_svg (const std::string &bitmap_name, unsigned target_width, unsigned target_height, unsigned outwidth, unsigned outheight)

Static Private Member Functions
static const char *	clipboard_get (void *user_data)
static void	clipboard_set (void user_data, const char text)

Private Attributes
const ImWchar *	m_glyph_ranges { nullptr }
const ImWchar *	m_glyph_basic_ranges { nullptr }
bool	m_font_cjk { false }
bool	m_is_korean { false }
float	m_font_size { 18.0 }
unsigned	m_font_texture { 0 }
unsigned	m_font_another_texture { 0 }
float	m_style_scaling { 1.0 }
unsigned	m_mouse_buttons { 0 }
bool	m_disabled { false }
bool	m_new_frame_open { false }
std::chrono::steady_clock::time_point	m_last_frame_time {}
std::map< wchar_t, int >	m_custom_glyph_rects_ids
std::string	m_clipboard_text
std::map< int, bool >	m_key_claims
std::optional< bool >	m_char_claim
LastSliderStatus	m_last_slider_status
ImFont *	default_font = nullptr
ImFont *	bold_font = nullptr
std::map< std::string, ImFont * >	im_fonts_map
std::vector< std::string >	m_fonts_names

Detailed Description

Constructor & Destructor Documentation

◆ ImGuiWrapper()

Slic3r::GUI::ImGuiWrapper::ImGuiWrapper ( )

{
    ImGui::CreateContext();
 
    init_input();
    init_style();
 
    ImGui::GetIO().IniFilename = nullptr;
}

References init_input(), and init_style().

Referenced by clipboard_get().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ~ImGuiWrapper()

Slic3r::GUI::ImGuiWrapper::~ImGuiWrapper ( )

{
    //destroy_fonts_texture();
    destroy_font();
    ImGui::DestroyContext();
}

References destroy_font().

Here is the call graph for this function:

Member Function Documentation

◆ bbl_button()

bool Slic3r::GUI::ImGuiWrapper::bbl_button	(	const wxString &	label,
		const wxString &	tooltip = {} )

{
    auto label_utf8 = into_u8(label);
    const bool ret = ImGui::BBLButton(label_utf8.c_str());
 
    if (!tooltip.IsEmpty() && ImGui::IsItemHovered()) {
        const float max_tooltip_width = ImGui::GetFontSize() * 20.0f;
        this->tooltip(tooltip, max_tooltip_width);
    }
 
    return ret;
}

References Slic3r::GUI::into_u8(), and tooltip().

Referenced by Slic3r::GUI::IMSlider::render_go_to_layer_dialog(), and Slic3r::GUI::IMSlider::render_input_custom_gcode().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bbl_checkbox()

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

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

References Slic3r::GUI::into_u8().

Referenced by Slic3r::GUI::GLCanvas3D::_render_arrange_menu(), Slic3r::GUI::GizmoObjectManipulation::do_render_scale_input_window(), Slic3r::GUI::Mouse3DController::render_settings_dialog(), and Slic3r::GUI::GLCanvas3D::LayersEditing::render_variable_layer_height_dialog().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bbl_combo_with_filter()

bool Slic3r::GUI::ImGuiWrapper::bbl_combo_with_filter	(	const char *	label,
		const std::string &	preview_value,
		const std::vector< std::string > &	all_items,
		std::vector< int > *	filtered_items_idx,
		bool *	is_filtered,
		float	item_height = 0.0f )

{
    ImGuiContext& g = *GImGui;
    const ImGuiStyle& style = g.Style;
    ImGuiWindow* window = ImGui::GetCurrentWindow();
    if (window->SkipItems)
        return false;
 
    static char pattern_buffer[256] = { 0 };
    auto simple_match = [](const char* pattern, const char* str) {
        wxString sub_str = wxString::FromUTF8(pattern).Lower();
        wxString main_str = wxString::FromUTF8(str).Lower();
        return main_str.Find(sub_str);
    };
 
    bool is_filtering = false;
    bool is_new_open = false;
 
    float sz = ImGui::GetFrameHeight();
    ImVec2 arrow_size(sz, sz);
    ImVec2 CursorPos = window->DC.CursorPos;
    const ImRect arrow_bb(CursorPos, CursorPos + arrow_size);
 
    float ButtonTextAlignX = g.Style.ButtonTextAlign.x;
    g.Style.ButtonTextAlign.x = 0;
    ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, { sz, style.FramePadding.y});
    ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImGui::GetStyleColorVec4(ImGuiCol_ButtonHovered));
    if (button(preview_value + label, ImGui::CalcItemWidth(), 0))
    {
        ImGui::OpenPopup(label);
        is_new_open = true;
    }
    g.Style.ButtonTextAlign.x = ButtonTextAlignX;
    ImGui::PopStyleVar();
    ImGui::PopStyleColor();
    ImGui::BBLRenderArrow(window->DrawList, arrow_bb.Min + ImVec2(ImMax(0.0f, (arrow_size.x - g.FontSize) * 0.5f), ImMax(0.0f, (arrow_size.y - g.FontSize) * 0.5f)), ImGui::GetColorU32(ImGuiCol_Text), ImGuiDir_Down);
 
    if (is_new_open)
        memset(pattern_buffer, 0, IM_ARRAYSIZE(pattern_buffer));
 
    float item_rect_width = ImGui::GetItemRectSize().x;
    float item_rect_height = item_height ? item_height : ImGui::GetItemRectSize().y;
    ImGui::SetNextWindowPos({ CursorPos.x, ImGui::GetItemRectMax().y + 4 * m_style_scaling });
    ImGui::SetNextWindowSize({ item_rect_width, 0 });
    if (ImGui::BeginPopup(label))
    {
        ImGuiWindow* popup_window = ImGui::GetCurrentWindow();
 
        ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(0, 0));
 
        ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(8.0f * m_style_scaling, item_rect_height - g.FontSize) * 0.5f);
        wchar_t ICON_SEARCH = *pattern_buffer != '\0' ? ImGui::TextSearchCloseIcon : ImGui::TextSearchIcon;
        const ImVec2 label_size = ImGui::CalcTextSize(into_u8(ICON_SEARCH).c_str(), nullptr, true);
        const ImVec2 search_icon_pos(ImGui::GetItemRectMax().x - label_size.x, popup_window->DC.CursorPos.y + style.FramePadding.y);
        ImGui::RenderText(search_icon_pos, into_u8(ICON_SEARCH).c_str());
 
        auto temp = popup_window->DC.CursorPos;
        popup_window->DC.CursorPos = search_icon_pos;
        ImGui::PushStyleColor(ImGuiCol_Button, {0, 0, 0, 0});
        ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImGui::GetStyleColorVec4(ImGuiCol_Button));
        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImGui::GetStyleColorVec4(ImGuiCol_Button));
        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImGui::GetStyleColorVec4(ImGuiCol_Button));
        ImGui::PushStyleColor(ImGuiCol_Border, { 0, 0, 0, 0 });
        if (button("##invisible_clear_button", label_size.x, label_size.y))
        {
            if (*pattern_buffer != '\0')
                memset(pattern_buffer, 0, IM_ARRAYSIZE(pattern_buffer));
        }
        ImGui::PopStyleColor(5);
        popup_window->DC.CursorPos = temp;
 
 
        ImGui::PushItemWidth(item_rect_width);
        if (is_new_open)
            ImGui::SetKeyboardFocusHere();
        ImGui::InputText("##bbl_combo_with_filter_inputText", pattern_buffer, sizeof(pattern_buffer));
        ImGui::PopItemWidth();
        ImGui::PopStyleVar();
 
        if (*pattern_buffer != '\0')
            is_filtering = true;
 
        if (is_filtering)
        {
            std::vector<std::pair<int, int> > filtered_items_with_priority;// std::pair<index, priority>
            for (int i = 0; i < all_items.size(); i++)
            {
                int priority = simple_match(pattern_buffer, all_items[i].c_str());
                if (priority != wxNOT_FOUND)
                    filtered_items_with_priority.push_back({ i, priority });
            }
            std::sort(filtered_items_with_priority.begin(), filtered_items_with_priority.end(), [](const std::pair<int, int>& a, const std::pair<int, int>& b) {return (b.second > a.second); });
            for (auto item : filtered_items_with_priority)
            {
                filtered_items_idx->push_back(item.first);
            }
        }
 
        *is_filtered = is_filtering;
 
        popup_window->DC.CursorPos.y -= 1 * m_style_scaling;
        ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(1.0f, 1.0f) * m_style_scaling);
        if (ImGui::BeginListBox("##bbl_combo_with_filter_listBox", { item_rect_width, item_rect_height * 7.75f})) {
            ImGui::PopStyleVar(2);
            return true;
        }
        else
        {
            ImGui::PopStyleVar(2);
            ImGui::EndPopup();
            return false;
        }
    }
    else
        return false;
}

References button(), ImRect, Slic3r::GUI::into_u8(), m_style_scaling, and style.

Here is the call graph for this function:

◆ bbl_input_double()

bool Slic3r::GUI::ImGuiWrapper::bbl_input_double	(	const wxString &	label,
		const double &	value,
		const std::string &	format = "%0.2f" )

{
    //return ImGui::InputDouble(label.c_str(), const_cast<double *>(&value), 0.0f, 0.0f, format.c_str(), ImGuiInputTextFlags_CharsDecimal);
    return ImGui::InputDouble(label.c_str(), const_cast<double *>(&value), 0.0f, 0.0f, format.c_str(), ImGuiInputTextFlags_CharsDecimal);
}

References Slic3r::GUI::format().

Here is the call graph for this function:

◆ bbl_radio_button()

bool Slic3r::GUI::ImGuiWrapper::bbl_radio_button	(	const char *	label,
		bool	active )

{
    bool result;
    bool b_value = active;
    if (b_value) {
        ImGui::PushStyleColor(ImGuiCol_FrameBg, ImVec4(0.00f, 0.59f, 0.53f, 1.00f));
        ImGui::PushStyleColor(ImGuiCol_FrameBgHovered, ImVec4(0.00f, 0.59f, 0.53f, 1.00f));
        ImGui::PushStyleColor(ImGuiCol_FrameBgActive, ImVec4(0.00f, 0.59f, 0.53f, 1.00f));
    }
    result = ImGui::BBLRadioButton(label,active);
    if (b_value) { ImGui::PopStyleColor(3); }
    return result;
}

◆ bbl_slider_float()

bool Slic3r::GUI::ImGuiWrapper::bbl_slider_float	(	const std::string &	label,
		float *	v,
		float	v_min,
		float	v_max,
		const char *	format = "%.3f",
		float	power = 1.0f,
		bool	clamp = true,
		const wxString &	tooltip = {} )

{
 
    const float max_tooltip_width = ImGui::GetFontSize() * 20.0f;
 
    // let the label string start with "##" to hide the automatic label from ImGui::SliderFloat()
    bool label_visible = !boost::algorithm::istarts_with(label, "##");
    std::string str_label = label_visible ? std::string("##") + std::string(label) : std::string(label);
 
    // removes 2nd evenience of "##", if present
    std::string::size_type pos = str_label.find("##", 2);
    if (pos != std::string::npos)
        str_label = str_label.substr(0, pos) + str_label.substr(pos + 2);
 
    bool ret = ImGui::BBLSliderFloat(str_label.c_str(), v, v_min, v_max, format, power);
 
    m_last_slider_status.hovered = ImGui::IsItemHovered();
    m_last_slider_status.edited = ImGui::IsItemEdited();
    m_last_slider_status.clicked = ImGui::IsItemClicked();
    m_last_slider_status.deactivated_after_edit = ImGui::IsItemDeactivatedAfterEdit();
 
    if (!tooltip.empty() && ImGui::IsItemHovered())
        this->tooltip(into_u8(tooltip).c_str(), max_tooltip_width);
 
    if (clamp)
        *v = std::clamp(*v, v_min, v_max);
 
    const ImGuiStyle& style = ImGui::GetStyle();
 
    if (label_visible) {
        // if the label is visible, hide the part of it that should be hidden
        std::string out_label = std::string(label);
        std::string::size_type pos = out_label.find("##");
        if (pos != std::string::npos)
            out_label = out_label.substr(0, pos);
 
        ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, { 1, style.ItemSpacing.y });
        ImGui::SameLine();
        this->text(out_label.c_str());
        ImGui::PopStyleVar();
    }
 
 
    return ret;
}

References Slic3r::GUI::format(), Slic3r::GUI::into_u8(), m_last_slider_status, style, text(), and tooltip().

Referenced by bbl_slider_float_style().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bbl_slider_float_style()

bool Slic3r::GUI::ImGuiWrapper::bbl_slider_float_style	(	const std::string &	label,
		float *	v,
		float	v_min,
		float	v_max,
		const char *	format = "%.3f",
		float	power = 1.0f,
		bool	clamp = true,
		const wxString &	tooltip = {} )

{
    ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 0.0f);
    ImGui::PushStyleColor(ImGuiCol_FrameBgHovered, ImVec4(238 / 255.0f, 238 / 255.0f, 238 / 255.0f, 0.00f));
    ImGui::PushStyleColor(ImGuiCol_FrameBgActive, ImVec4(238 / 255.0f, 238 / 255.0f, 238 / 255.0f, 0.00f));
    ImGui::PushStyleColor(ImGuiCol_SliderGrab, ImVec4(0.81f, 0.81f, 0.81f, 1.0f));
    ImGui::PushStyleColor(ImGuiCol_SliderGrabActive, ImVec4(0.00f, 0.59f, 0.53f, 1.00f));
 
    bool ret = bbl_slider_float(label, v, v_min,v_max, format, power, clamp,tooltip);
 
    ImGui::PopStyleColor(4);
    ImGui::PopStyleVar(1);
 
    return ret;
}

References bbl_slider_float(), Slic3r::GUI::format(), and tooltip().

Referenced by Slic3r::GUI::GLCanvas3D::_render_arrange_menu(), Slic3r::GUI::GLCanvas3D::_render_assemble_control(), Slic3r::GUI::GLCanvas3D::_render_section_view_panel(), Slic3r::GUI::Mouse3DController::render_settings_dialog(), and Slic3r::GUI::GLCanvas3D::LayersEditing::render_variable_layer_height_dialog().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bbl_sliderin()

bool Slic3r::GUI::ImGuiWrapper::bbl_sliderin	(	const char *	label,
		int *	v,
		int	v_min,
		int	v_max,
		const char *	format = "%d",
		ImGuiSliderFlags	flags = 0 )

{
    return ImGui::BBLSliderScalarIn(label, ImGuiDataType_S32, v, &v_min, &v_max, format, flags);
}

References Slic3r::GUI::format().

Here is the call graph for this function:

◆ begin() [1/4]

bool Slic3r::GUI::ImGuiWrapper::begin	(	const std::string &	name,
		bool *	close,
		int	flags = 0 )

{
    return ImGui::Begin(name.c_str(), close, (ImGuiWindowFlags)flags);
}

◆ begin() [2/4]

bool Slic3r::GUI::ImGuiWrapper::begin	(	const std::string &	name,
		int	flags = 0 )

{
    return ImGui::Begin(name.c_str(), nullptr, (ImGuiWindowFlags)flags);
}

Here is the caller graph for this function:

◆ begin() [3/4]

bool Slic3r::GUI::ImGuiWrapper::begin	(	const wxString &	name,
		bool *	close,
		int	flags = 0 )

{
    return begin(into_u8(name), close, flags);
}

References begin(), and Slic3r::GUI::into_u8().

Here is the call graph for this function:

◆ begin() [4/4]

bool Slic3r::GUI::ImGuiWrapper::begin	(	const wxString &	name,
		int	flags = 0 )

{
    return begin(into_u8(name), flags);
}

References begin(), and Slic3r::GUI::into_u8().

Here is the call graph for this function:

◆ bold_text()

void Slic3r::GUI::ImGuiWrapper::bold_text ( const std::string & str )

{
    if (bold_font){
        ImGui::PushFont(bold_font);
        text(str);
        ImGui::PopFont();
    } else {
        text(str);
    }
}

References bold_font, and text().

Referenced by Slic3r::GUI::GCodeViewer::render_all_plates_stats(), and Slic3r::GUI::GCodeViewer::render_legend_color_arr_recommen().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ button() [1/3]

bool Slic3r::GUI::ImGuiWrapper::button	(	const wxString &	label,
		const ImVec2 &	size,
		bool	enable )

{
    disabled_begin(!enable);
 
    auto label_utf8 = into_u8(label);
    bool res = ImGui::Button(label_utf8.c_str(), size);
 
    disabled_end();
    return (enable) ? res : false;
}

References disabled_begin(), disabled_end(), and Slic3r::GUI::into_u8().

Here is the call graph for this function:

◆ button() [2/3]

bool Slic3r::GUI::ImGuiWrapper::button	(	const wxString &	label,
		const wxString &	tooltip = {} )

{
    auto label_utf8 = into_u8(label);
    const bool ret = ImGui::Button(label_utf8.c_str());
 
    if (!tooltip.IsEmpty() && ImGui::IsItemHovered()) {
        const float max_tooltip_width = ImGui::GetFontSize() * 20.0f;
        this->tooltip(tooltip, max_tooltip_width);
    }
 
    return ret;
}

References Slic3r::GUI::into_u8(), and tooltip().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ button() [3/3]

bool Slic3r::GUI::ImGuiWrapper::button	(	const wxString &	label,
		float	width,
		float	height )

{
    auto label_utf8 = into_u8(label);
    return ImGui::Button(label_utf8.c_str(), ImVec2(width, height));
}

References Slic3r::GUI::into_u8().

Here is the call graph for this function:

◆ calc_button_size()

ImVec2 Slic3r::GUI::ImGuiWrapper::calc_button_size	(	const wxString &	text,
		const ImVec2 &	button_size = ImVec2(0, 0) ) const

{
    const ImVec2        text_size = this->calc_text_size(text);
    const ImGuiContext &g         = *GImGui;
    const ImGuiStyle   &style     = g.Style;
 
    return ImGui::CalcItemSize(button_size, text_size.x + style.FramePadding.x * 2.0f, text_size.y + style.FramePadding.y * 2.0f);
}

References calc_text_size(), style, and text().

Here is the call graph for this function:

◆ calc_text_size() [1/3]

ImVec2 Slic3r::GUI::ImGuiWrapper::calc_text_size	(	const std::string &	text,
		bool	hide_text_after_double_hash = false,
		float	wrap_width = -1.0f )

static

{
    return ImGui::CalcTextSize(text.c_str(), NULL, hide_text_after_double_hash, wrap_width);
}

References text().

Here is the call graph for this function:

◆ calc_text_size() [2/3]

ImVec2 Slic3r::GUI::ImGuiWrapper::calc_text_size	(	const wxString &	text,
		bool	hide_text_after_double_hash = false,
		float	wrap_width = -1.0f )

static

{
    auto text_utf8 = into_u8(text);
    ImVec2 size = ImGui::CalcTextSize(text_utf8.c_str(), NULL, hide_text_after_double_hash, wrap_width);
 
/*#ifdef __linux__
    size.x *= m_style_scaling;
    size.y *= m_style_scaling;
#endif*/
 
    return size;
}

References Slic3r::GUI::into_u8(), and text().

Here is the call graph for this function:

◆ calc_text_size() [3/3]

ImVec2 Slic3r::GUI::ImGuiWrapper::calc_text_size	(	std::string_view	text,
		bool	hide_text_after_double_hash = false,
		float	wrap_width = -1.0f )

static

Extend ImGui::CalcTextSize to use string_view.

{
    return ImGui::CalcTextSize(text.data(), text.data() + text.length(),
                               hide_text_after_double_hash, wrap_width);
}

References text().

Referenced by Slic3r::GUI::GLCanvas3D::_render_arrange_menu(), Slic3r::GUI::GLCanvas3D::_render_assemble_control(), Slic3r::GUI::GLCanvas3D::_render_assemble_info(), Slic3r::GUI::GLCanvas3D::_render_assembly_tooltip_button(), Slic3r::GUI::GLGizmoUtils::begin_right_aligned_buttons(), calc_button_size(), Slic3r::GUI::GizmoObjectManipulation::do_render_move_window(), Slic3r::GUI::GizmoObjectManipulation::do_render_rotate_window(), Slic3r::GUI::GizmoObjectManipulation::do_render_scale_input_window(), filament_group(), find_widest_text(), Slic3r::GUI::GLCanvas3D::Labels::render(), Slic3r::GUI::GLGizmoCut3D::render_cut_plane_input_window(), Slic3r::GUI::GCodeViewer::render_legend_color_arr_recommen(), Slic3r::GUI::Mouse3DController::render_settings_dialog(), Slic3r::GUI::GLGizmoUtils::render_tooltip_button(), and trunc().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ calculate_filament_group_text_size()

std::tuple< ImVec2, bool > Slic3r::GUI::ImGuiWrapper::calculate_filament_group_text_size ( const std::string & filament_type )

{
    ImVec2             text_size = ImGui::CalcTextSize(filament_type.c_str());
    float         four_word_width = ImGui::CalcTextSize("ABCD").x;
 
    float wrap_width = four_word_width;
    float line_height = ImGui::GetTextLineHeight();
 
    bool is_multiline = text_size.x > wrap_width;
    int line_count = std::ceil(text_size.x / wrap_width);
    float text_height = line_count * line_height;
 
    float final_width = is_multiline ? wrap_width : text_size.x;
    float final_height = line_count * line_height;
 
    return { { final_width,final_height },is_multiline };
}

References Slic3r::filament_type().

Referenced by filament_group(), and Slic3r::GUI::GCodeViewer::render_legend_color_arr_recommen().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ change_window_position()

std::optional< ImVec2 > Slic3r::GUI::ImGuiWrapper::change_window_position	(	const char *	window_name,
		bool	try_to_fix )

static

Change position of imgui window.

Parameters

window_name	ImGui identifier of window
output_window_offset	[output] optional
try_to_fix	When True Only move to be full visible otherwise reset position

Returns: New offset of window for function ImGui::SetNextWindowPos

                                                                                                 {
    ImGuiWindow *window = ImGui::FindWindowByName(window_name);
    // is window just created
    if (window == NULL)
        return {};
 
    // position of window on screen
    ImVec2 position = window->Pos;
    ImVec2 size     = window->SizeFull;
 
    // screen size
    ImVec2 screen = ImGui::GetMainViewport()->Size;
 
    std::optional<ImVec2> output_window_offset;
    if (position.x < 0) {
        if (position.y < 0)
            // top left 
            output_window_offset = ImVec2(0, 0); 
        else
            // only left
            output_window_offset = ImVec2(0, position.y); 
    } else if (position.y < 0) {
        // only top
        output_window_offset = ImVec2(position.x, 0); 
    } else if (screen.x < (position.x + size.x)) {
        if (screen.y < (position.y + size.y))
            // right bottom
            output_window_offset = ImVec2(screen.x - size.x, screen.y - size.y);
        else
            // only right
            output_window_offset = ImVec2(screen.x - size.x, position.y);
    } else if (screen.y < (position.y + size.y)) {
        // only bottom
        output_window_offset = ImVec2(position.x, screen.y - size.y);
    }
 
    if (!try_to_fix && output_window_offset.has_value())
        output_window_offset = ImVec2(-1, -1); // Put on default position
 
    return output_window_offset;
}

◆ checkbox()

bool Slic3r::GUI::ImGuiWrapper::checkbox	(	const wxString &	label,
		bool &	value )

{
    auto label_utf8 = into_u8(label);
    return ImGui::Checkbox(label_utf8.c_str(), &value);
}

References Slic3r::GUI::into_u8().

Referenced by Slic3r::GUI::GLCanvas3D::_render_orient_menu(), and search_list().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ claim_key_event()

bool Slic3r::GUI::ImGuiWrapper::claim_key_event ( const wxKeyEvent & evt )

{
    const bool claimed = owns_keyboard();
    const int  key     = evt.GetKeyCode();
    if (evt.GetEventType() == wxEVT_KEY_DOWN) {
        m_char_claim = m_key_claims.try_emplace(key, claimed).first->second;
        return *m_char_claim;
    }
    if (evt.GetEventType() == wxEVT_KEY_UP) {
        m_char_claim.reset();
        if (const auto press = m_key_claims.extract(key))
            return press.mapped();
        return claimed;
    }
    return std::exchange(m_char_claim, std::nullopt).value_or(claimed);
}

References m_char_claim, m_key_claims, and owns_keyboard().

Here is the call graph for this function:

◆ clipboard_get()

const char * Slic3r::GUI::ImGuiWrapper::clipboard_get ( void * user_data )

staticprivate

{
    ImGuiWrapper* self = reinterpret_cast<ImGuiWrapper*>(user_data);
 
    const char* res = "";
 
    if (wxTheClipboard->Open()) {
        if (wxTheClipboard->IsSupported(wxDF_TEXT) || wxTheClipboard->IsSupported(wxDF_UNICODETEXT)) {
            wxTextDataObject data;
            wxTheClipboard->GetData(data);
 
            const wxString text = data.GetText();
            if (text.Length() > 0) {
                self->m_clipboard_text = into_u8(text);
                res = self->m_clipboard_text.c_str();
            }
        }
 
        wxTheClipboard->Close();
    }
 
    return res;
}

References ImGuiWrapper(), Slic3r::GUI::into_u8(), m_clipboard_text, and text().

Referenced by init_input().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ clipboard_set()

void Slic3r::GUI::ImGuiWrapper::clipboard_set	(	void *	user_data,
		const char *	text )

staticprivate

{
    if (wxTheClipboard->Open()) {
        wxTheClipboard->SetData(new wxTextDataObject(wxString::FromUTF8(text)));   // object owned by the clipboard
        wxTheClipboard->Close();
    }
}

References text().

Referenced by init_input().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ close_top_popup()

void Slic3r::GUI::ImGuiWrapper::close_top_popup ( )

{
    const ImVector<ImGuiPopupData>& stack = ImGui::GetCurrentContext()->OpenPopupStack;
    for (int level = stack.Size - 1; level >= 0; --level) {
        const ImGuiWindow* popup = stack[level].Window;
        if (!drawn_last_frame(popup))
            continue;
        if ((popup->Flags & ImGuiWindowFlags_Modal) == 0)
            ImGui::ClosePopupToLevel(level, true);
        return;
    }
}

References Slic3r::GUI::drawn_last_frame().

Here is the call graph for this function:

◆ combo() [1/2]

bool Slic3r::GUI::ImGuiWrapper::combo	(	const std::string &	label,
		const std::vector< std::string > &	options,
		int &	selection,
		ImGuiComboFlags	flags = 0,
		float	label_width = 0.0f,
		float	item_width = 0.0f )

{
    // this is to force the label to the left of the widget:
    const bool hidden_label = boost::starts_with(label, "##");
    if (!label.empty() && !hidden_label) {
        text(label);
        ImGui::SameLine(label_width);
    }
    ImGui::PushItemWidth(item_width);
 
    int selection_out = selection;
    bool res = false;
 
    const char *selection_str = selection < int(options.size()) && selection >= 0 ? options[selection].c_str() : "";
    if (ImGui::BeginCombo(hidden_label ? label.c_str() : ("##" + label).c_str(), selection_str, flags)) {
        for (int i = 0; i < (int)options.size(); i++) {
            if (ImGui::Selectable(options[i].c_str(), i == selection)) {
                selection_out = i;
                res = true;
            }
        }
 
        ImGui::EndCombo();
    }
 
    selection = selection_out;
    return res;
}

References text().

Referenced by combo().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ combo() [2/2]

bool Slic3r::GUI::ImGuiWrapper::combo	(	const wxString &	label,
		const std::vector< std::string > &	options,
		int &	selection,
		ImGuiComboFlags	flags = 0,
		float	label_width = 0.0f,
		float	item_width = 0.0f )

{
    return combo(into_u8(label), options, selection, flags, label_width, item_width);
}

References combo(), and Slic3r::GUI::into_u8().

Here is the call graph for this function:

◆ contain_all_glyphs()

bool Slic3r::GUI::ImGuiWrapper::contain_all_glyphs	(	const ImFont *	font,
		const std::string &	text )

static

Check that font ranges contain all chars in string (rendered Unicodes are stored in GlyphRanges).

Parameters

font	Contain glyph ranges
text	Vector of character to check

Returns: True when all glyphs from text are in font ranges

{
    if (font == nullptr) return false;
    if (!font->IsLoaded()) return false;
    const ImFontConfig *fc = font->ConfigData;
    if (fc == nullptr) return false;
    if (text.empty()) return true;
    return is_chars_in_ranges(fc->GlyphRanges, text.c_str());
}

References is_chars_in_ranges(), and text().

Referenced by Slic3r::GUI::GLGizmoEmboss::draw_text_input().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ destroy_font()

void Slic3r::GUI::ImGuiWrapper::destroy_font ( )

private

{
    if (m_font_texture != 0) {
        ImGuiIO& io = ImGui::GetIO();
        io.Fonts->TexID = 0;
        glsafe(::glDeleteTextures(1, &m_font_texture));
        m_font_texture = 0;
    }
}

References glDeleteTextures, glsafe, and m_font_texture.

Referenced by ~ImGuiWrapper(), init_font(), set_language(), and set_scaling().

Here is the caller graph for this function:

◆ destroy_fonts_texture()

void Slic3r::GUI::ImGuiWrapper::destroy_fonts_texture ( )

                                         {
    //if (m_font_another_texture != 0) {
    //    if (m_new_frame_open) {
    //        render();
    //    }
    //    init_font(true);
    //    glsafe(::glDeleteTextures(1, &m_font_another_texture));
    //    m_font_another_texture = 0;
    //    if (!m_new_frame_open) {
    //        new_frame();
    //    }
    //}
}

◆ disable_background_fadeout_animation()

void Slic3r::GUI::ImGuiWrapper::disable_background_fadeout_animation ( )

{
    GImGui->DimBgRatio = 1.0f;
}

◆ disabled_begin()

void Slic3r::GUI::ImGuiWrapper::disabled_begin ( bool disabled )

{
    wxCHECK_RET(!m_disabled, "ImGUI: Unbalanced disabled_begin() call");
 
    if (disabled) {
        ImGui::PushItemFlag(ImGuiItemFlags_Disabled, true);
        ImGui::PushStyleVar(ImGuiStyleVar_Alpha, ImGui::GetStyle().Alpha * 0.5f);
        m_disabled = true;
    }
}

References m_disabled.

Referenced by Slic3r::GUI::GLGizmoRotate3D::RotoptimzeWindow::RotoptimzeWindow(), Slic3r::GUI::GLCanvas3D::_render_arrange_menu(), Slic3r::GUI::GLCanvas3D::_render_section_view_panel(), button(), Slic3r::GUI::GizmoObjectManipulation::do_render_move_window(), Slic3r::GUI::GLCanvas3D::LayersEditing::render_variable_layer_height_dialog(), Slic3r::GUI::GizmoObjectManipulation::reset_button(), and Slic3r::GUI::GizmoObjectManipulation::reset_zero_button().

Here is the caller graph for this function:

◆ disabled_end()

void Slic3r::GUI::ImGuiWrapper::disabled_end ( )

{
    if (m_disabled) {
        ImGui::PopItemFlag();
        ImGui::PopStyleVar();
        m_disabled = false;
    }
}

References m_disabled.

Referenced by Slic3r::GUI::GLGizmoRotate3D::RotoptimzeWindow::RotoptimzeWindow(), Slic3r::GUI::GLCanvas3D::_render_arrange_menu(), Slic3r::GUI::GLCanvas3D::_render_section_view_panel(), button(), Slic3r::GUI::GizmoObjectManipulation::do_render_move_window(), Slic3r::GUI::GLCanvas3D::LayersEditing::render_variable_layer_height_dialog(), Slic3r::GUI::GizmoObjectManipulation::reset_button(), and Slic3r::GUI::GizmoObjectManipulation::reset_zero_button().

Here is the caller graph for this function:

◆ display_initialized()

bool Slic3r::GUI::ImGuiWrapper::display_initialized ( ) const

{
    const ImGuiIO& io = ImGui::GetIO();
    return io.DisplaySize.x >= 0.0f && io.DisplaySize.y >= 0.0f;
}

Referenced by update_key_data(), and update_mouse_data().

Here is the caller graph for this function:

◆ drag_optional_float()

bool Slic3r::GUI::ImGuiWrapper::drag_optional_float	(	const char *	label,
		std::optional< float > &	v,
		float	v_speed,
		float	v_min,
		float	v_max,
		const char *	format,
		float	power,
		float	def_val = .0f )

static

{
    auto func = [&](float &value) {
        return ImGui::DragFloat(label, &value, v_speed, v_min, v_max, format, power);
    };
    std::function<bool(const float &)> is_default =
        [def_val](const float &value) -> bool {
        return std::fabs(value-def_val) <= std::numeric_limits<float>::epsilon();
    };
    return input_optional(v, func, is_default, def_val);
}

References Slic3r::GUI::format(), and Slic3r::GUI::input_optional().

Here is the call graph for this function:

◆ draw()

void Slic3r::GUI::ImGuiWrapper::draw	(	const Polygon &	polygon,
		ImDrawList *	draw_list = ImGui::GetOverlayDrawList(),
		ImU32	color = ImGui::GetColorU32(COL_ORANGE_LIGHT),
		float	thickness = 3.f )

static

Visualization of polygon.

Parameters

polygon	Define what to draw
draw_list	Define where to draw it
color	Color of polygon
thickness	Width of polygon line

{
    // minimal one line consist of 2 points
    if (polygon.size() < 2) return;
    // need a place to draw
    if (draw_list == nullptr) return;
 
    const Point *prev_point = &polygon.points.back();
    for (const Point &point : polygon.points) {
        ImVec2 p1(prev_point->x(), prev_point->y());
        ImVec2 p2(point.x(), point.y());
        draw_list->AddLine(p1, p2, color, thickness);
        prev_point = &point;
    }
}

References Slic3r::MultiPoint::points, and Slic3r::MultiPoint::size().

Here is the call graph for this function:

◆ draw_cross_hair()

void Slic3r::GUI::ImGuiWrapper::draw_cross_hair	(	const ImVec2 &	position,
		float	radius = 16.f,
		ImU32	color = ImGui::GetColorU32(ImVec4(1.f, 1.f, 1.f, .75f)),
		int	num_segments = 0,
		float	thickness = 4.f )

static

Draw symbol of cross hair.

Parameters

position	Center of cross hair
radius	Circle radius
color	Color of symbol
num_segments	Precission of circle
thickness	Thickness of Line in symbol

                                                                                                                       {
    auto draw_list = ImGui::GetOverlayDrawList();
    draw_list->AddCircle(position, radius, color, num_segments, thickness);
    auto dirs = {ImVec2{0, 1}, ImVec2{1, 0}, ImVec2{0, -1}, ImVec2{-1, 0}};
    for (const ImVec2 &dir : dirs) {
        ImVec2 start(position.x + dir.x * 0.5 * radius, position.y + dir.y * 0.5 * radius);
        ImVec2 end(position.x + dir.x * 1.5 * radius, position.y + dir.y * 1.5 * radius);
        draw_list->AddLine(start, end, color, thickness);
    }
}

References end().

Referenced by Slic3r::GUI::GLGizmoEmboss::on_render_input_window(), and Slic3r::GUI::GLGizmoSVG::on_render_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ draw_data_signature()

ImGuiID Slic3r::GUI::ImGuiWrapper::draw_data_signature ( const ImDrawData * draw_data )

static

{
    ImGuiID hash = 0;
    if (draw_data == nullptr)
        return hash;
 
    for (int i = 0; i < draw_data->CmdListsCount; ++i) {
        const ImDrawList* list = draw_data->CmdLists[i];
        hash = ImHashData(list->VtxBuffer.Data, list->VtxBuffer.Size * sizeof(ImDrawVert), hash);
        hash = ImHashData(list->IdxBuffer.Data, list->IdxBuffer.Size * sizeof(ImDrawIdx), hash);
        // ImDrawCmd has padding, and a hovered ImageButton3() differs only in TextureId.
        for (const ImDrawCmd& cmd : list->CmdBuffer) {
            hash = ImHashData(&cmd.ClipRect, sizeof(cmd.ClipRect), hash);
            hash = ImHashData(&cmd.TextureId, sizeof(cmd.TextureId), hash);
            hash = ImHashData(&cmd.VtxOffset, sizeof(cmd.VtxOffset), hash);
            hash = ImHashData(&cmd.IdxOffset, sizeof(cmd.IdxOffset), hash);
            hash = ImHashData(&cmd.ElemCount, sizeof(cmd.ElemCount), hash);
            hash = ImHashData(&cmd.UserCallback, sizeof(cmd.UserCallback), hash);
        }
    }
    return hash;
}

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

Here is the caller graph for this function:

◆ draw_gradient_ramp()

void Slic3r::GUI::ImGuiWrapper::draw_gradient_ramp	(	ImDrawList *	draw_list,
		const ImVec2 &	top_left,
		const ImVec2 &	bottom_right,
		const std::vector< wxColour > &	ramp )

static

Fill a rect with a filament gradient ramp, one band per pixel row, ramp.front() along the bottom edge. Bands rather than one interpolated rect, because the ramp follows the slot's gradient curve and ImGui's corner interpolation could only draw a straight fade.

Parameters

draw_list	Define where to draw it
top_left	Upper left corner of the rect
bottom_right	Lower right corner of the rect
ramp	Colours printed, bottom of the model first

{
    if (draw_list == nullptr || ramp.empty() || bottom_right.x <= top_left.x || bottom_right.y <= top_left.y)
        return;
 
    const int    rows  = std::max(1, (int) std::lround(bottom_right.y - top_left.y));
    const float  row_h = (bottom_right.y - top_left.y) / rows;
    const size_t last  = ramp.size() - 1;
    for (int r = 0; r < rows; ++r) {
        // Row 0 is the top of the rect and so takes the ramp's last entry, the model's top.
        const double    t = (rows > 1) ? (double) (rows - 1 - r) / (rows - 1) : 0.5;
        const wxColour &c = ramp[(size_t) (t * last + 0.5)];
        // The bottom row snaps to the rect's edge so rounding never leaves a sliver uncovered.
        const float y0 = top_left.y + r * row_h;
        const float y1 = (r + 1 == rows) ? bottom_right.y : top_left.y + (r + 1) * row_h;
        draw_list->AddRectFilled({top_left.x, y0}, {bottom_right.x, y1}, IM_COL32(c.Red(), c.Green(), c.Blue(), c.Alpha()));
    }
}

Referenced by Slic3r::GUI::GLCanvas3D::_render_paint_toolbar(), and Slic3r::GUI::GLGizmoMmuSegmentation::draw_color_button().

Here is the caller graph for this function:

◆ end()

void Slic3r::GUI::ImGuiWrapper::end ( )

{
    ImGui::End();
}

Here is the caller graph for this function:

◆ end_frame()

ImDrawData * Slic3r::GUI::ImGuiWrapper::end_frame ( )

{
#ifdef __APPLE__
    // io.ImeWindowHandle is the focused canvas' view (GLCanvas3D::on_set_focus()).
    if (void* view = ImGui::GetIO().ImeWindowHandle)
        mac_ime_set_active(view, ImGui::GetIO().WantTextInput);
#endif
    ImGui::Render();
    m_new_frame_open = false;
    return ImGui::GetDrawData();
}

References m_new_frame_open, and Slic3r::GUI::mac_ime_set_active().

Here is the call graph for this function:

◆ escape_double_hash()

void Slic3r::GUI::ImGuiWrapper::escape_double_hash ( std::string & text )

static

Escape ## in data by add space between hashes Needed when user written text is visualized by ImGui.

Parameters

text	In/Out text to be escaped

{
    // add space between hashes
    const std::string search  = "##";
    const std::string replace = "# #";
    size_t pos = 0;
    while ((pos = text.find(search, pos)) != std::string::npos) 
        text.replace(pos, search.length(), replace);
}

References text().

Referenced by Slic3r::GUI::GLGizmoEmboss::draw_style_list(), and Slic3r::GUI::Emboss::StyleManager::init_trunc_names().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ filament_group()

void Slic3r::GUI::ImGuiWrapper::filament_group	(	const std::string &	filament_type,
		const char *	hex_color,
		unsigned char	filament_id,
		float	align_width )

{
    //ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0, 0));
    std::string id = std::to_string(static_cast<unsigned int> (filament_id + 1));
    ImDrawList* draw_list = ImGui::GetWindowDrawList();
    static ImTextureID transparent;
    ImVec2             text_size = ImGui::CalcTextSize(filament_type.c_str());
    // BBS image sizing based on text width (DPI scaling)
    float         img_width = ImGui::CalcTextSize("ABC").x;
    ImVec2        img_size = { img_width, img_width };
    ImVec2        id_text_size = this->calc_text_size(id);
    unsigned char rgba[4];
    rgba[3] = 0xff;
    Slic3r::GUI::BitmapCache::parse_color4(hex_color, rgba);
    std::string svg_path = "/images/outlined_rect.svg";
    if (rgba[3] == 0x00) {
        svg_path = "/images/outlined_rect_transparent.svg";
    }
    BitmapCache::load_from_svg_file_change_color(Slic3r::resources_dir() + svg_path, img_size.x, img_size.y, transparent, hex_color);
    ImGui::BeginGroup();
    {
        ImVec2 cursor_pos = ImGui::GetCursorScreenPos();
        draw_list->AddImage(transparent, cursor_pos, { cursor_pos.x + img_size.x, cursor_pos.y + img_size.y }, { 0, 0 }, { 1, 1 }, ImGui::GetColorU32(ImVec4(1.f, 1.f, 1.f, 1.f)));
        // image border test
        // draw_list->AddRect(cursor_pos, {cursor_pos.x + img_size.x, cursor_pos.y + img_size.y}, IM_COL32(0, 0, 0, 255));
        ImVec2 current_cursor = ImGui::GetCursorPos();
        ImGui::SetCursorPos({ current_cursor.x + (img_size.x - id_text_size.x) * 0.5f, current_cursor.y + (img_size.y - id_text_size.y) * 0.5f });
 
        float gray = 0.299 * rgba[0] + 0.587 * rgba[1] + 0.114 * rgba[2];
        ImVec4 text_color = gray < 80 ? ImVec4(1.0f, 1.0f, 1.0f, 1.0f) : ImVec4(0, 0, 0, 1.0f);
        this->text_colored(text_color, id.c_str());
 
        auto wrapped_text_info = calculate_filament_group_text_size(filament_type);
        ImVec2 wrapped_text_size = std::get<0>(wrapped_text_info);
        bool is_multiline = std::get<1>(wrapped_text_info);
 
        float text_y_offset = 4.f;
        float text_x_offset = is_multiline ? (img_size.x - wrapped_text_size.x) * 0.5f + 2.f : (img_size.x - wrapped_text_size.x) * 0.5f + 2.f;
 
        auto cursor_x_before_text = ImGui::GetCursorPosX();
        current_cursor = ImGui::GetCursorPos();
        ImGui::SetCursorPos({
            current_cursor.x + text_x_offset,
            current_cursor.y + text_y_offset
            });
 
        if (is_multiline) {
            ImGui::PushTextWrapPos(ImGui::GetCursorPosX() + wrapped_text_size.x);
        }
        this->text(filament_type);
        if (is_multiline) {
            ImGui::PopTextWrapPos();
        }
        ImGui::Dummy(ImVec2(align_width, 0));
        ImGui::EndGroup();
    }
    //ImGui::PopStyleVar(1);
}

References calc_text_size(), calculate_filament_group_text_size(), Slic3r::filament_type(), Slic3r::GUI::BitmapCache::load_from_svg_file_change_color(), Slic3r::GUI::BitmapCache::parse_color4(), Slic3r::resources_dir(), text(), text_color(), and text_colored().

Referenced by Slic3r::GUI::GCodeViewer::render_legend_color_arr_recommen().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ find_widest_text()

float Slic3r::GUI::ImGuiWrapper::find_widest_text ( std::vector< wxString > & text_list )

{
    float width = .0f;
    for(const wxString &text : text_list) {
        width = std::max(width, this->calc_text_size(text).x);
    }
    return width;
}

References calc_text_size(), and text().

Here is the call graph for this function:

◆ forget_key_claims()

void Slic3r::GUI::ImGuiWrapper::forget_key_claims ( )

{
    m_key_claims.clear();
    m_char_claim.reset();
}

References m_char_claim, and m_key_claims.

◆ from_ImU32()

ColorRGBA Slic3r::GUI::ImGuiWrapper::from_ImU32 ( const ImU32 & color )

static

{
    return from_ImVec4(ImGui::ColorConvertU32ToFloat4(color));
}

References from_ImVec4().

Here is the call graph for this function:

◆ from_ImVec4()

ColorRGBA Slic3r::GUI::ImGuiWrapper::from_ImVec4 ( const ImVec4 & color )

static

{
    return { color.x, color.y, color.z, color.w };
}

Referenced by from_ImU32(), Slic3r::GLVolume::update_render_colors(), Slic3r::GUI::Bed3D::update_render_colors(), Slic3r::GUI::GLCanvas3D::update_render_colors(), Slic3r::GUI::GLGizmoBase::update_render_colors(), and Slic3r::GUI::PartPlate::update_render_colors().

Here is the caller graph for this function:

◆ get_font_size()

float Slic3r::GUI::ImGuiWrapper::get_font_size ( ) const

inline

108{ return m_font_size; }

Slic3r::GUI::ImGuiWrapper::m_font_size

float m_font_size

Definition ImGuiWrapper.hpp:65

References m_font_size.

Referenced by Slic3r::GUI::DailyTipsPanel::DailyTipsPanel(), Slic3r::GUI::DailyTipsPanel::push_styles(), Slic3r::GUI::DailyTipsPanel::render(), Slic3r::GUI::DailyTipsWindow::render(), Slic3r::GUI::NotificationManager::SlicingProgressNotification::render(), Slic3r::GUI::DailyTipsPanel::render_controller_buttons(), and Slic3r::GUI::NotificationManager::SlicingProgressNotification::render_progress_text().

Here is the caller graph for this function:

◆ get_fonts_names()

const std::vector< std::string > Slic3r::GUI::ImGuiWrapper::get_fonts_names ( ) const

inline

215{ return m_fonts_names; }

Slic3r::GUI::ImGuiWrapper::m_fonts_names

std::vector< std::string > m_fonts_names

Definition ImGuiWrapper.hpp:454

References m_fonts_names.

◆ get_glyph_ranges()

const ImWchar * Slic3r::GUI::ImGuiWrapper::get_glyph_ranges ( ) const

inline

110{ return m_glyph_ranges; } // language specific

Slic3r::GUI::ImGuiWrapper::m_glyph_ranges

const ImWchar * m_glyph_ranges

Definition ImGuiWrapper.hpp:60

References m_glyph_ranges.

◆ get_item_spacing()

ImVec2 Slic3r::GUI::ImGuiWrapper::get_item_spacing ( ) const

{
    const ImGuiContext &g     = *GImGui;
    const ImGuiStyle   &style = g.Style;
    return style.ItemSpacing;
}

References style.

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

Here is the caller graph for this function:

◆ get_last_slider_status() [1/2]

LastSliderStatus & Slic3r::GUI::ImGuiWrapper::get_last_slider_status ( )

inline

132{ return m_last_slider_status; }

References m_last_slider_status.

◆ get_last_slider_status() [2/2]

const LastSliderStatus & Slic3r::GUI::ImGuiWrapper::get_last_slider_status ( ) const

inline

131{ return m_last_slider_status; }

References m_last_slider_status.

◆ get_slider_float_height()

float Slic3r::GUI::ImGuiWrapper::get_slider_float_height ( ) const

{
    const ImGuiContext& g = *GImGui;
    const ImGuiStyle& style = g.Style;
    return g.FontSize + style.FramePadding.y * 2.0f + style.ItemSpacing.y;
}

References style.

◆ get_style_scaling()

float Slic3r::GUI::ImGuiWrapper::get_style_scaling ( ) const

inline

109{ return m_style_scaling; }

References m_style_scaling.

Referenced by Slic3r::GUI::GLCanvas3D::_render_assemble_info(), Slic3r::GUI::GizmoObjectManipulation::do_render_move_window(), Slic3r::GUI::GizmoObjectManipulation::do_render_rotate_window(), Slic3r::GUI::GizmoObjectManipulation::do_render_scale_input_window(), Slic3r::GUI::DesignCanvas::render_hud(), and Slic3r::GUI::Mouse3DController::render_settings_dialog().

Here is the caller graph for this function:

◆ GetTextureCustomRect()

ImFontAtlasCustomRect * Slic3r::GUI::ImGuiWrapper::GetTextureCustomRect ( const wchar_t & tex_id )

{
    auto item = m_custom_glyph_rects_ids.find(tex_id);
    return (item != m_custom_glyph_rects_ids.end()) ? ImGui::GetIO().Fonts->GetCustomRectByIndex(m_custom_glyph_rects_ids[tex_id]) : nullptr;
}

References m_custom_glyph_rects_ids.

Referenced by image_button().

Here is the caller graph for this function:

◆ glyph_button()

bool Slic3r::GUI::ImGuiWrapper::glyph_button	(	wchar_t	icon_char,
		ImVec2	icon_size )

{
    ImDrawList* draw_list = ImGui::GetWindowDrawList();
    ImFont*     font      = ImGui::GetFont();
    ImGuiStyle& style     = ImGui::GetStyle();
    ImVec2      padding   = style.FramePadding;
    float       border_w  = style.FrameBorderSize;
    float       rounding  = style.FrameRounding;
    std::string icon_str  = into_u8(icon_char);
    const char* icon      = icon_str.c_str();
    
    float  width  = icon_size.x + (padding.x + border_w) * 2.f;
    float  height = icon_size.y + (padding.y + border_w) * 2.f;
    ImVec2 rc_min = ImGui::GetCursorScreenPos();
    ImVec2 rc_max = ImVec2(rc_min.x + width, rc_min.y + height);
 
    ImGui::Dummy(ImVec2(width, height));
 
    ImGuiCol bg_color     = ImGuiCol_Button;
    ImGuiCol border_color = ImGuiCol_Border;
    bool     clicked      = false;
 
    if (ImGui::IsMouseHoveringRect(rc_min, rc_max)) {
        bg_color = ImGuiCol_ButtonHovered;
        if (ImGui::IsMouseClicked(ImGuiMouseButton_Left)) {
            bg_color     = ImGuiCol_ButtonActive;
            border_color = ImGuiCol_BorderShadow;
            clicked      = true;
        }
    }
 
    draw_list->AddRectFilled(rc_min, rc_max, ImGui::GetColorU32(bg_color), rounding);
 
    if (border_w > 0.f)
        draw_list->AddRect(rc_min, rc_max, ImGui::GetColorU32(border_color), rounding, 0, border_w);
 
    ImVec2 text_pos = ImVec2(
        rc_min.x + (width  - font->FontSize) * .5f,
        rc_min.y + (height - font->FontSize) * .5f
    );
    draw_list->AddText(font, font->FontSize, text_pos, ImGui::GetColorU32(ImGuiCol_Text), icon);
 
    return clicked;
}

References Slic3r::GUI::into_u8(), and style.

Referenced by Slic3r::GUI::GCodeViewer::SequentialView::Marker::render_position_window().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ image_button() [1/2]

bool Slic3r::GUI::ImGuiWrapper::image_button	(	const wchar_t	icon,
		const wxString &	tooltip = L"" )

{
    const ImGuiIO& io = ImGui::GetIO();
    const ImTextureID tex_id = io.Fonts->TexID;
    assert(io.Fonts->TexWidth > 0 && io.Fonts->TexHeight > 0);
    const float inv_tex_w = 1.0f / float(io.Fonts->TexWidth);
    const float inv_tex_h = 1.0f / float(io.Fonts->TexHeight);
    const ImFontAtlasCustomRect* const rect = GetTextureCustomRect(icon);
    const ImVec2 size = { float(rect->Width), float(rect->Height) };
    const ImVec2 uv0 = ImVec2(float(rect->X) * inv_tex_w, float(rect->Y) * inv_tex_h);
    const ImVec2 uv1 = ImVec2(float(rect->X + rect->Width) * inv_tex_w, float(rect->Y + rect->Height) * inv_tex_h);
    ImGui::PushStyleColor(ImGuiCol_Button, { 0.25f, 0.25f, 0.25f, 0.0f });
    ImGui::PushStyleColor(ImGuiCol_ButtonHovered, { 0.4f, 0.4f, 0.4f, 1.0f });
    ImGui::PushStyleColor(ImGuiCol_ButtonActive, { 0.25f, 0.25f, 0.25f, 1.0f });
    const bool res = image_button(tex_id, size, uv0, uv1);
    ImGui::PopStyleColor(3);
 
    if (!tooltip.empty() && ImGui::IsItemHovered())
        this->tooltip(tooltip, ImGui::GetFontSize() * 20.0f);
 
    return res;
}

References GetTextureCustomRect(), image_button(), and tooltip().

Here is the call graph for this function:

◆ image_button() [2/2]

bool Slic3r::GUI::ImGuiWrapper::image_button	(	ImTextureID	user_texture_id,
		const ImVec2 &	size,
		const ImVec2 &	uv0 = ImVec2(0.0, 0.0),
		const ImVec2 &	uv1 = ImVec2(1.0, 1.0),
		int	frame_padding = -1,
		const ImVec4 &	bg_col = ImVec4(0.0, 0.0, 0.0, 0.0),
		const ImVec4 &	tint_col = ImVec4(1.0, 1.0, 1.0, 1.0),
		ImGuiButtonFlags	flags = 0 )

{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    if (window->SkipItems)
        return false;
 
    // Default to using texture ID as ID. User can still push string/integer prefixes.
    ImGui::PushID((void*)(intptr_t)user_texture_id);
    const ImGuiID id = window->GetID("#image");
    ImGui::PopID();
 
    const ImVec2 padding = (frame_padding >= 0) ? ImVec2((float)frame_padding, (float)frame_padding) : g.Style.FramePadding;
    return image_button_ex(id, user_texture_id, size, uv0, uv1, padding, bg_col, tint_col, flags);
}

References Slic3r::GUI::image_button_ex().

Referenced by image_button().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ init_font()

void Slic3r::GUI::ImGuiWrapper::init_font ( bool compress )

private

{
    destroy_font();
 
    ImGuiIO& io = ImGui::GetIO();
    io.Fonts->Clear();
 
    // Create ranges of characters from m_glyph_ranges, possibly adding some OS specific special characters.
    ImVector<ImWchar> ranges;
    ImVector<ImWchar> basic_ranges;
    ImFontAtlas::GlyphRangesBuilder builder;
    builder.AddRanges(m_glyph_ranges);
    builder.AddRanges(ImGui::GetIO().Fonts->GetGlyphRangesDefault());
    builder.AddRanges(ranges_language_independent);
#ifdef __APPLE__
    if (m_font_cjk)
        // Apple keyboard shortcuts are only contained in the CJK fonts.
        builder.AddRanges(ranges_keyboard_shortcuts);
#endif
    builder.BuildRanges(&ranges); // Build the final result (ordered ranges with all the unique characters submitted)
 
    io.Fonts->Flags |= ImFontAtlasFlags_NoPowerOfTwoHeight;
    // TexDesiredWidth will be increased adaptively below if the built height
    // exceeds GL_MAX_TEXTURE_SIZE. Leave it at 0 so ImGui picks the minimum
    // width for small glyph sets and we only widen when actually necessary.
    io.Fonts->TexDesiredWidth = 0;
 
    ImFontConfig cfg = ImFontConfig();
    cfg.OversampleH = cfg.OversampleV = 1;
    //FIXME replace with io.Fonts->AddFontFromMemoryTTF(buf_decompressed_data, (int)buf_decompressed_size, m_font_size, nullptr, ranges.Data);
    //https://github.com/ocornut/imgui/issues/220
 
    // Orca: temp fix for Korean font
    auto font_name_regular = "HarmonyOS_Sans_SC_Regular.ttf";
    auto font_name_bold = "HarmonyOS_Sans_SC_Bold.ttf";
    // The Korean and Thai fonts cover their own script and little else, so they need the
    // default font merged in behind them to reach the full range.
    bool needs_glyph_fallback = false;
    if(m_glyph_ranges == ImGui::GetIO().Fonts->GetGlyphRangesKorean()) {
        font_name_regular = "NanumGothic-Regular.ttf";
        font_name_bold = "NanumGothic-Bold.ttf";
        needs_glyph_fallback = true;
    } else if (m_glyph_ranges == ImGui::GetIO().Fonts->GetGlyphRangesThai()) {
        font_name_regular = "Sarabun-Medium.ttf";
        font_name_bold = "Sarabun-SemiBold.ttf";
        needs_glyph_fallback = true;
    }
    default_font = io.Fonts->AddFontFromFileTTF((Slic3r::resources_dir() + "/fonts/" + font_name_regular).c_str(), m_font_size, &cfg, ranges.Data);
    if (default_font == nullptr) {
        default_font = io.Fonts->AddFontDefault();
        if (default_font == nullptr) {
            throw Slic3r::RuntimeError("ImGui: Could not load deafult font");
        }
    }
 
    // A merged font only supplies glyphs the font ahead of it lacks, so this fills the gaps
    // without restyling anything the script font already covers.
    if (needs_glyph_fallback) {
        ImFontConfig fallback_cfg = cfg;
        fallback_cfg.MergeMode = true;
        io.Fonts->AddFontFromFileTTF((Slic3r::resources_dir() + "/fonts/HarmonyOS_Sans_SC_Regular.ttf").c_str(), m_font_size, &fallback_cfg, ranges.Data);
    }
 
    bold_font        = io.Fonts->AddFontFromFileTTF((Slic3r::resources_dir() + "/fonts/" + font_name_bold).c_str(), m_font_size, &cfg, ranges.Data);
    if (bold_font == nullptr) {
        bold_font = io.Fonts->AddFontDefault();
        if (bold_font == nullptr) { throw Slic3r::RuntimeError("ImGui: Could not load deafult font"); }
    }
 
    if (needs_glyph_fallback) {
        ImFontConfig fallback_cfg = cfg;
        fallback_cfg.MergeMode = true;
        io.Fonts->AddFontFromFileTTF((Slic3r::resources_dir() + "/fonts/HarmonyOS_Sans_SC_Bold.ttf").c_str(), m_font_size, &fallback_cfg, ranges.Data);
    }
 
    if (m_glyph_ranges == ImGui::GetIO().Fonts->GetGlyphRangesThai()) {
        default_font->Scale *= 1.25f;
        bold_font->Scale *= 1.25f;
    }
 
#ifdef _WIN32
    // Render the text a bit larger (see GLCanvas3D::_resize() and issue #3401), but only if the scale factor
    // for the Display is greater than 300%.
    if (wxGetApp().em_unit() > 30) {
        default_font->Scale = 1.5f;
        bold_font->Scale    = 1.5f;
    }
#endif
 
#ifdef __APPLE__
    ImFontConfig config;
    config.MergeMode = true;
    if (! m_font_cjk) {
        // Apple keyboard shortcuts are only contained in the CJK fonts.
        [[maybe_unused]]ImFont *font_cjk = io.Fonts->AddFontFromFileTTF((Slic3r::resources_dir() + "/fonts/HarmonyOS_Sans_SC_Regular.ttf").c_str(), m_font_size, &config, ranges_keyboard_shortcuts);
        assert(font_cjk != nullptr);
    }
#endif
 
    float font_scale = m_font_size/15;
    int icon_sz = lround(16 * font_scale); // default size of icon is 16 px
 
    int rect_id = io.Fonts->CustomRects.Size;  // id of the rectangle added next
    // add rectangles for the icons to the font atlas
    for (auto& icon : font_icons) {
        m_custom_glyph_rects_ids[icon.first] =
        io.Fonts->AddCustomRectFontGlyph(default_font, icon.first, icon_sz, icon_sz, 3.0 * font_scale + icon_sz);
    }
    for (auto& icon : font_icons_large) {
        m_custom_glyph_rects_ids[icon.first] =
        io.Fonts->AddCustomRectFontGlyph(default_font, icon.first, icon_sz * 2, icon_sz * 2, 3.0 * font_scale + icon_sz * 2);
    }
    for (auto& icon : font_icons_extra_large) {
        m_custom_glyph_rects_ids[icon.first] =
        io.Fonts->AddCustomRectFontGlyph(default_font, icon.first, icon_sz * 4, icon_sz * 4, 3.0 * font_scale + icon_sz * 4);
    }
 
    // Build texture atlas, widening it if the height would exceed GL_MAX_TEXTURE_SIZE.
    // Increasing the width allows the packing algorithm to grow more horizontally which reduces the height.
    io.Fonts->Build();
    GLint gl_max_tex_size = 0;
    glsafe(::glGetIntegerv(GL_MAX_TEXTURE_SIZE, &gl_max_tex_size));
    constexpr int max_retries = 6;
    for (int attempt = 0; attempt < max_retries && io.Fonts->TexHeight > gl_max_tex_size; ++attempt) {
        const int width = io.Fonts->TexDesiredWidth > 0 ? io.Fonts->TexDesiredWidth : io.Fonts->TexWidth;
        // Both dimensions share the same limit, so widening past it would only trade an
        // illegal height for an illegal width.
        if (width * 2 > gl_max_tex_size)
            break;
        io.Fonts->TexDesiredWidth = width * 2;
        io.Fonts->Build();
    }
    if (io.Fonts->TexHeight > gl_max_tex_size) {
        // Needs both a very large glyph set and a small GL_MAX_TEXTURE_SIZE.
        BOOST_LOG_TRIVIAL(error) << "Font atlas " << io.Fonts->TexWidth << "x" << io.Fonts->TexHeight
            << " does not fit GL_MAX_TEXTURE_SIZE (" << gl_max_tex_size << ")"
            << " after " << max_retries << " attempts; rendering may be incomplete";
    }
 
    unsigned char* pixels;
    int width, height;
    io.Fonts->GetTexDataAsRGBA32(&pixels, &width, &height);   // Load as RGBA 32-bits (75% of the memory is wasted, but default font is so small) because it is more likely to be compatible with user's existing shaders. If your ImTextureId represent a higher-level concept than just a GL texture id, consider calling GetTexDataAsAlpha8() instead to save on GPU memory.
    BOOST_LOG_TRIVIAL(trace) << "Build default font texture done. width: " << width << ", height: " << height;
 
    auto load_icon_from_svg = [this, &io, pixels, width, &rect_id](const std::pair<const wchar_t, std::string> icon, int icon_sz) {
        if (const ImFontAtlas::CustomRect* rect = io.Fonts->GetCustomRectByIndex(rect_id)) {
            assert(rect->Width == icon_sz);
            assert(rect->Height == icon_sz);
            unsigned                   outwidth, outheight;
            std::vector<unsigned char> raw_data = load_svg(icon.second, icon_sz, icon_sz, &outwidth, &outheight);
            if (!raw_data.empty()) {
                const ImU32* pIn = (ImU32*)raw_data.data();
                for (unsigned y = 0; y < outheight; y++) {
                    ImU32* pOut = (ImU32*)pixels + (rect->Y + y) * width + (rect->X);
                    for (unsigned x = 0; x < outwidth; x++)
                        *pOut++ = *pIn++;
                }
            }
        }
        rect_id++;
    };
 
    // Fill rectangles from the SVG-icons
    for (auto icon : font_icons) {
        load_icon_from_svg(icon, icon_sz);
    }
 
    icon_sz *= 2; // default size of large icon is 32 px
    for (auto icon : font_icons_large) {
        load_icon_from_svg(icon, icon_sz);
    }
 
    icon_sz *= 2; // default size of extra large icon is 64 px
    for (auto icon : font_icons_extra_large) {
        load_icon_from_svg(icon, icon_sz);
    }
 
    // Upload texture to graphics system
    GLint last_texture;
    glsafe(::glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture));
    glsafe(::glGenTextures(1, &m_font_texture));
    glsafe(::glBindTexture(GL_TEXTURE_2D, m_font_texture));
    glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
    glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
    glsafe(::glPixelStorei(GL_UNPACK_ROW_LENGTH, 0));
    if (compress && GLAD_GL_EXT_texture_compression_s3tc)
        glsafe(::glTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels));
    else
        glsafe(::glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels));
 
    // Store our identifier
    io.Fonts->TexID = (ImTextureID)(intptr_t)m_font_texture;
 
    // Restore state
    glsafe(::glBindTexture(GL_TEXTURE_2D, last_texture));
}

References bold_font, default_font, destroy_font(), em_unit(), Slic3r::GUI::font_icons, Slic3r::GUI::font_icons_extra_large, Slic3r::GUI::font_icons_large, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GL_LINEAR, GL_MAX_TEXTURE_SIZE, GL_RGBA, GL_TEXTURE_2D, GL_TEXTURE_BINDING_2D, GL_TEXTURE_MAG_FILTER, GL_TEXTURE_MIN_FILTER, GL_UNPACK_ROW_LENGTH, GL_UNSIGNED_BYTE, GLAD_GL_EXT_texture_compression_s3tc, glBindTexture, glGenTextures, glGetIntegerv, glPixelStorei, glsafe, glTexImage2D, glTexParameteri, load_svg(), m_custom_glyph_rects_ids, m_font_cjk, m_font_size, m_font_texture, m_glyph_ranges, Slic3r::GUI::ranges_language_independent, Slic3r::resources_dir(), and Slic3r::trace().

Referenced by new_frame().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ init_input()

void Slic3r::GUI::ImGuiWrapper::init_input ( )

private

{
    ImGuiIO& io = ImGui::GetIO();
 
    // Keyboard mapping. ImGui will use those indices to peek into the io.KeysDown[] array.
    io.KeyMap[ImGuiKey_Tab] = WXK_TAB;
    io.KeyMap[ImGuiKey_LeftArrow] = WXK_LEFT;
    io.KeyMap[ImGuiKey_RightArrow] = WXK_RIGHT;
    io.KeyMap[ImGuiKey_UpArrow] = WXK_UP;
    io.KeyMap[ImGuiKey_DownArrow] = WXK_DOWN;
    io.KeyMap[ImGuiKey_PageUp] = WXK_PAGEUP;
    io.KeyMap[ImGuiKey_PageDown] = WXK_PAGEDOWN;
    io.KeyMap[ImGuiKey_Home] = WXK_HOME;
    io.KeyMap[ImGuiKey_End] = WXK_END;
    io.KeyMap[ImGuiKey_Insert] = WXK_INSERT;
    io.KeyMap[ImGuiKey_Delete] = WXK_DELETE;
    io.KeyMap[ImGuiKey_Backspace] = WXK_BACK;
    io.KeyMap[ImGuiKey_Space] = WXK_SPACE;
    io.KeyMap[ImGuiKey_Enter] = WXK_RETURN;
    io.KeyMap[ImGuiKey_KeyPadEnter] = WXK_NUMPAD_ENTER;
    io.KeyMap[ImGuiKey_Escape] = WXK_ESCAPE;
    io.KeyMap[ImGuiKey_A] = 'A';
    io.KeyMap[ImGuiKey_C] = 'C';
    io.KeyMap[ImGuiKey_V] = 'V';
    io.KeyMap[ImGuiKey_X] = 'X';
    io.KeyMap[ImGuiKey_Y] = 'Y';
    io.KeyMap[ImGuiKey_Z] = 'Z';
 
    // Don't let imgui special-case Mac, wxWidgets already do that
    io.ConfigMacOSXBehaviors = false;
 
#ifdef __APPLE__
    // Places the input method's candidate window at the text cursor.
    io.ImeSetInputScreenPosFn = [](int x, int y) {
        if (void* view = ImGui::GetIO().ImeWindowHandle)
            mac_ime_set_caret(view, x, y, int(ImGui::GetFontSize()));
    };
#endif
 
    // Setup clipboard interaction callbacks
    io.SetClipboardTextFn = clipboard_set;
    io.GetClipboardTextFn = clipboard_get;
    io.ClipboardUserData = this;
}

References clipboard_get(), clipboard_set(), and Slic3r::GUI::mac_ime_set_caret().

Referenced by ImGuiWrapper().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ init_style()

void Slic3r::GUI::ImGuiWrapper::init_style ( )

private

{
    ImGuiStyle &style = ImGui::GetStyle();
 
    auto set_color = [&](ImGuiCol_ entity, ImVec4 color) {
        style.Colors[entity] = color;
    };
 
    //BBS modify style
    // Window
    style.WindowRounding = 0.0f;
    set_color(ImGuiCol_WindowBg, COL_WINDOW_BACKGROUND);
    set_color(ImGuiCol_TitleBgActive, COL_WINDOW_BACKGROUND);
 
    // Generics
    set_color(ImGuiCol_FrameBg, COL_GREY_DARK);
    set_color(ImGuiCol_FrameBgHovered, COL_GREY_LIGHT);
    set_color(ImGuiCol_FrameBgActive, COL_GREY_LIGHT);
 
    // Text selection
    set_color(ImGuiCol_TextSelectedBg, COL_ORANGE_DARK);
 
    // Buttons
    set_color(ImGuiCol_Button, COL_BUTTON_BACKGROUND);
    set_color(ImGuiCol_ButtonHovered, COL_HOVER);
    set_color(ImGuiCol_ButtonActive, COL_ACTIVE);
 
    // Checkbox
    set_color(ImGuiCol_CheckMark, COL_BLUE_LIGHT);
 
    // ComboBox items
    set_color(ImGuiCol_Header, COL_ORANGE_DARK);
    set_color(ImGuiCol_HeaderHovered, to_ImVec4(to_rgba(ColorRGB::ORCA(), 0.50f))); // ORCA Use orca color for headers
    set_color(ImGuiCol_HeaderActive,  to_ImVec4(to_rgba(ColorRGB::ORCA(), 0.75f)));  // ORCA Use orca color for headers
 
    // Slider
    set_color(ImGuiCol_SliderGrab,      to_ImVec4(to_rgba(ColorRGB::ORCA(), 0.50f))); // ORCA Use orca color for slider thumbs 
    set_color(ImGuiCol_SliderGrabActive,  to_ImVec4(to_rgba(ColorRGB::ORCA(), 0.75f))); // ORCA Use orca color for slider thumbs 
 
    // Separator
    set_color(ImGuiCol_Separator, COL_BLUE_LIGHT);
 
    // Tabs
    set_color(ImGuiCol_Tab, COL_ORANGE_DARK);
    set_color(ImGuiCol_TabHovered, COL_BLUE_LIGHT);
    set_color(ImGuiCol_TabActive, COL_BLUE_LIGHT);
    set_color(ImGuiCol_TabUnfocused, COL_GREY_DARK);
    set_color(ImGuiCol_TabUnfocusedActive, COL_GREY_LIGHT);
 
    // Scrollbars
    set_color(ImGuiCol_ScrollbarGrab, COL_ORANGE_DARK);
    set_color(ImGuiCol_ScrollbarGrabHovered, COL_ORANGE_LIGHT);
    set_color(ImGuiCol_ScrollbarGrabActive, COL_ORANGE_LIGHT);
}

References COL_ACTIVE, COL_BLUE_LIGHT, COL_BUTTON_BACKGROUND, COL_GREY_DARK, COL_GREY_LIGHT, COL_HOVER, COL_ORANGE_DARK, COL_ORANGE_LIGHT, COL_WINDOW_BACKGROUND, Slic3r::ColorRGB::ORCA(), style, to_ImVec4(), and Slic3r::to_rgba().

Referenced by ImGuiWrapper().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ input_double() [1/2]

bool Slic3r::GUI::ImGuiWrapper::input_double	(	const std::string &	label,
		const double &	value,
		const std::string &	format = "%.3f" )

{
    return ImGui::InputDouble(label.c_str(), const_cast<double*>(&value), 0.0f, 0.0f, format.c_str(), ImGuiInputTextFlags_CharsDecimal);
}

References Slic3r::GUI::format().

Referenced by input_double().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ input_double() [2/2]

bool Slic3r::GUI::ImGuiWrapper::input_double	(	const wxString &	label,
		const double &	value,
		const std::string &	format = "%.3f" )

{
    auto label_utf8 = into_u8(label);
    return input_double(label_utf8, value, format);
}

References Slic3r::GUI::format(), input_double(), and Slic3r::GUI::into_u8().

Here is the call graph for this function:

◆ input_optional_float()

bool Slic3r::GUI::ImGuiWrapper::input_optional_float	(	const char *	label,
		std::optional< float > &	v,
		float	step = 0.0f,
		float	step_fast = 0.0f,
		const char *	format = "%.3f",
		ImGuiInputTextFlags	flags = 0,
		float	def_val = .0f )

static

{
    auto func = [&](float &value) {
        return ImGui::InputFloat(label, &value, step, step_fast, format, flags);
    };
    std::function<bool(const float &)> is_default =
        [def_val](const float &value) -> bool {
        return std::fabs(value-def_val) <= std::numeric_limits<float>::epsilon();
    };
    return input_optional(v, func, is_default, def_val);
}

References Slic3r::GUI::format(), and Slic3r::GUI::input_optional().

Here is the call graph for this function:

◆ input_optional_int()

bool Slic3r::GUI::ImGuiWrapper::input_optional_int	(	const char *	label,
		std::optional< int > &	v,
		int	step = 1,
		int	step_fast = 100,
		ImGuiInputTextFlags	flags = 0,
		int	def_val = 0 )

static

{
    auto func = [&](int &value) {
        return ImGui::InputInt(label, &value, step, step_fast, flags);
    };
    std::function<bool(const int &)> is_default = 
        [def_val](const int &value) -> bool { return value == def_val; };
    return input_optional(v, func, is_default, def_val);
}

References Slic3r::GUI::input_optional().

Here is the call graph for this function:

◆ input_vec3()

bool Slic3r::GUI::ImGuiWrapper::input_vec3	(	const std::string &	label,
		const Vec3d &	value,
		float	width,
		const std::string &	format = "%.3f" )

{
    bool value_changed = false;
 
    ImGui::BeginGroup();
 
    for (int i = 0; i < 3; ++i)
    {
        std::string item_label = (i == 0) ? "X" : ((i == 1) ? "Y" : "Z");
        ImGui::PushID(i);
        ImGui::PushItemWidth(width);
        value_changed |= ImGui::InputDouble(item_label.c_str(), const_cast<double*>(&value(i)), 0.0f, 0.0f, format.c_str());
        ImGui::PopID();
    }
    ImGui::EndGroup();
 
    return value_changed;
}

References Slic3r::GUI::format().

Here is the call graph for this function:

◆ is_char_in_ranges()

bool Slic3r::GUI::ImGuiWrapper::is_char_in_ranges	(	const ImWchar *	ranges,
		unsigned int	letter )

static

{
    for (const ImWchar *range = ranges; range[0] && range[1]; range += 2) {
        ImWchar from = range[0];
        ImWchar to   = range[1];
        if (from <= letter && letter <= to) return true;
        if (letter < to) return false; // ranges should be sorted
    }
    return false;
};

References Slic3r::range().

Referenced by is_chars_in_ranges().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_chars_in_ranges()

bool Slic3r::GUI::ImGuiWrapper::is_chars_in_ranges	(	const ImWchar *	ranges,
		const char *	chars_ptr )

static

{
    while (*chars_ptr) {
        unsigned int c = 0;
        // UTF-8 to 32-bit character need imgui_internal
        int c_len = ImTextCharFromUtf8(&c, chars_ptr, NULL);
        chars_ptr += c_len;
        if (c_len == 0) break;
        if (!is_char_in_ranges(ranges, c)) return false;
    }
    return true;
}

References is_char_in_ranges().

Referenced by contain_all_glyphs().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ item_held()

bool Slic3r::GUI::ImGuiWrapper::item_held ( ) const

{
    return ImGui::GetIO().MouseDown[0] && ImGui::GetActiveID() != 0;
}

Referenced by owns_keyboard().

Here is the caller graph for this function:

◆ left_inputs()

void Slic3r::GUI::ImGuiWrapper::left_inputs ( )

static

Use ImGui internals to unactivate (lose focus) in input. When input is activ it can't change value by application.

                               { 
    ImGui::ClearActiveID(); 
}

Referenced by Slic3r::GUI::GLGizmoEmboss::set_volume_by_selection(), and Slic3r::GUI::GLGizmoSVG::set_volume_by_selection().

Here is the caller graph for this function:

◆ load_fonts_texture()

void Slic3r::GUI::ImGuiWrapper::load_fonts_texture ( )

{
    //if (m_font_another_texture == 0) {
    //    ImGuiIO& io = ImGui::GetIO();
    //    io.Fonts->Flags |= ImFontAtlasFlags_NoPowerOfTwoHeight;
    //    ImFontConfig cfg = ImFontConfig();
    //    cfg.OversampleH = cfg.OversampleV = 1;
    //    im_fonts_map.clear();                                                     // map<font name, ImFont*>
    //    BOOST_LOG_TRIVIAL(info) << "init_im_font start";
    //    for (auto sys_font : sys_fonts_map) {
    //        boost::filesystem::path font_path(sys_font.second);
    //        if (!boost::filesystem::exists(font_path)) {
    //            BOOST_LOG_TRIVIAL(trace) << "load font = " << sys_font.first << ", path = " << font_path << " is not exists";
    //            continue;
    //        }
    //        ImFont* im_font = io.Fonts->AddFontFromFileTTF(sys_font.second.c_str(), m_font_size, &cfg, ImGui::GetIO().Fonts->GetGlyphRangesBasic());
    //        if (im_font == nullptr) {
    //            BOOST_LOG_TRIVIAL(trace) << "load font = " << sys_font.first << " failed, path = " << font_path << " is not exists";
    //            continue;
    //        }
    //        im_fonts_map.insert({ sys_font.first, im_font });
    //    }
    //    BOOST_LOG_TRIVIAL(info) << "init_im_font end";
 
    //    unsigned char* pixels;
    //    int            width, height;
    //    io.Fonts->GetTexDataAsRGBA32(&pixels, &width, &height);
    //    BOOST_LOG_TRIVIAL(trace) << "Build system fonts texture done. width: " << width << ", height: " << height;
 
    //    if (m_fonts_names.size() == 0) {
    //        std::vector<std::string> to_delete_fonts;
    //        for (auto im_font : im_fonts_map) {
    //            if (im_font.second->Glyphs.Size < 4) { to_delete_fonts.push_back(im_font.first); }
    //        }
    //        for (auto to_delete_font : to_delete_fonts) {
    //            sys_fonts_map.erase(to_delete_font);
    //            im_fonts_map.erase(to_delete_font);
    //        }
    //        for (auto im_font : im_fonts_map) m_fonts_names.push_back(im_font.first);
    //    }
 
    //    GLint last_texture;
    //    glsafe(::glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture));
    //    glsafe(::glGenTextures(1, &(m_font_another_texture)));
    //    glsafe(::glBindTexture(GL_TEXTURE_2D, m_font_another_texture));
    //    glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
    //    glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
    //    glsafe(::glPixelStorei(GL_UNPACK_ROW_LENGTH, 0));
 
    //    glsafe(::glTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels));
 
    //    // Store our identifier
    //    io.Fonts->TexID = (ImTextureID)(intptr_t)m_font_another_texture;
 
    //    // Restore state
    //    glsafe(::glBindTexture(GL_TEXTURE_2D, last_texture));
    //}
}

◆ load_svg()

std::vector< unsigned char > Slic3r::GUI::ImGuiWrapper::load_svg	(	const std::string &	bitmap_name,
		unsigned	target_width,
		unsigned	target_height,
		unsigned *	outwidth,
		unsigned *	outheight )

private

{
    std::vector<unsigned char> empty_vector;
 
    NSVGimage* image = BitmapCache::nsvgParseFromFileWithReplace(Slic3r::var(bitmap_name + ".svg").c_str(), "px", 96.0f, { { "\"#808080\"", "\"#FFFFFF\"" } });
    if (image == nullptr)
        return empty_vector;
 
    float svg_scale = target_height != 0 ?
        (float)target_height / image->height : target_width != 0 ?
        (float)target_width / image->width : 1;
 
    int   width = (int)(svg_scale * image->width + 0.5f);
    int   height = (int)(svg_scale * image->height + 0.5f);
    int   n_pixels = width * height;
    if (n_pixels <= 0) {
        ::nsvgDelete(image);
        return empty_vector;
    }
 
    NSVGrasterizer* rast = ::nsvgCreateRasterizer();
    if (rast == nullptr) {
        ::nsvgDelete(image);
        return empty_vector;
    }
 
    std::vector<unsigned char> data(n_pixels * 4, 0);
    ::nsvgRasterize(rast, image, 0, 0, svg_scale, data.data(), width, height, width * 4);
    ::nsvgDeleteRasterizer(rast);
    ::nsvgDelete(image);
 
    *outwidth = width;
    *outheight = height;
 
    return data;
}

References Slic3r::GUI::BitmapCache::nsvgParseFromFileWithReplace(), and Slic3r::var().

Referenced by init_font().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ modal_popup_open()

bool Slic3r::GUI::ImGuiWrapper::modal_popup_open ( ) const

{
    return drawn_last_frame(ImGui::GetTopMostPopupModal());
}

References Slic3r::GUI::drawn_last_frame().

Referenced by owns_key().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ new_frame()

void Slic3r::GUI::ImGuiWrapper::new_frame ( )

{
    if (m_new_frame_open) {
        return;
    }
 
    if (m_font_texture == 0) {
        init_font(true);
    }
 
    ImGuiIO& io = ImGui::GetIO();
 
    // ORCA ImGui times button and key repeat with io.DeltaTime. At its default of 1/60 s per frame the clock
    // counts frames, so a held +/- button repeats as fast as the canvas renders. Feed it the real frame time,
    // capped at 1/60 s so the idle gaps of the event-driven canvas don't count as time held.
    const auto now = std::chrono::steady_clock::now();
    if (m_last_frame_time != std::chrono::steady_clock::time_point{}) {
        const float dt = std::chrono::duration<float>(now - m_last_frame_time).count();
        io.DeltaTime   = std::clamp(dt, 1e-4f, 1.f / 60.f); // ImGui asserts a positive DeltaTime
    }
    m_last_frame_time = now;
 
    ImGui::NewFrame();
    m_new_frame_open = true;
 
    // BBL: we should render the new frame first, than reset keys' status
    // BBL: copy & paste form prusa github repo (https://github.com/prusa3d/PrusaSlicer/blob/master/src/slic3r/GUI/ImGuiWrapper.cpp#L375C5-L402C6)
    // synchronize key states
    // when the application loses the focus it may happen that the key up event is not processed
 
    // Not sure if it is neccessary
    // values from 33 to 126 are reserved for the standard ASCII characters
    for (size_t i = 33; i <= 126; ++i) {
        wxKeyCode keycode = static_cast<wxKeyCode>(i);
        if (io.KeysDown[i] && keycode != WXK_NONE && !wxGetKeyState(keycode))
            io.KeysDown[i] = false;
    }
 
    // special keys: delete, backspace, ...
    for (int key : io.KeyMap) {
        wxKeyCode keycode = static_cast<wxKeyCode>(key);
        if (io.KeysDown[key] && keycode != WXK_NONE && !wxGetKeyState(keycode))
            io.KeysDown[key] = false;
    }
 
    // BBL: end copy & paste
}

References init_font(), m_font_texture, m_last_frame_time, and m_new_frame_open.

Referenced by update_key_data(), and update_mouse_data().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ on_change_color_mode()

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

static

{
    m_is_dark_mode = is_dark;
}

References is_dark(), and Slic3r::GUI::m_is_dark_mode.

Here is the call graph for this function:

◆ owns_key()

bool Slic3r::GUI::ImGuiWrapper::owns_key ( const KeyChord & chord ) const

{
    return modal_popup_open() || (chord.edits_text() && text_input_active());
}

References Slic3r::GUI::KeyChord::edits_text(), modal_popup_open(), and text_input_active().

Referenced by Slic3r::GUI::MainFrame::handle_global_shortcut().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ owns_keyboard()

bool Slic3r::GUI::ImGuiWrapper::owns_keyboard ( ) const

{
    return popup_open() || item_held() || text_input_active();
}

References item_held(), popup_open(), and text_input_active().

Referenced by claim_key_event(), and Slic3r::GUI::MainFrame::init_menubar_as_editor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ pop_bold_font()

bool Slic3r::GUI::ImGuiWrapper::pop_bold_font ( )

                                 {
    if (bold_font) {
        ImGui::PopFont();
        return true;
    }
    else {
        return false;
    }
}

References bold_font.

Referenced by Slic3r::GUI::GLCanvas3D::_render_paint_toolbar(), Slic3r::GUI::DailyTipsWindow::render(), Slic3r::GUI::DailyTipsPanel::render_controller_buttons(), and Slic3r::GUI::NotificationManager::SlicingProgressNotification::render_progress_text().

Here is the caller graph for this function:

◆ pop_button_disable_style()

void Slic3r::GUI::ImGuiWrapper::pop_button_disable_style ( )

static

                                            {
    ImGui::PopStyleColor(3);
}

Referenced by Slic3r::GUI::IMSlider::render_go_to_layer_dialog(), and Slic3r::GUI::IMSlider::render_input_custom_gcode().

Here is the caller graph for this function:

◆ pop_cancel_button_style()

void Slic3r::GUI::ImGuiWrapper::pop_cancel_button_style ( )

static

                                           {
    ImGui::PopStyleColor(6);
}

Referenced by Slic3r::GUI::GLGizmoMeasure::render_dimensioning(), Slic3r::GUI::IMSlider::render_go_to_layer_dialog(), and Slic3r::GUI::IMSlider::render_input_custom_gcode().

Here is the caller graph for this function:

◆ pop_combo_style()

void Slic3r::GUI::ImGuiWrapper::pop_combo_style ( )

static

{
    ImGui::PopStyleVar(2);
    ImGui::PopStyleColor(7);
}

Referenced by Slic3r::GUI::GLCanvas3D::_render_assemble_control(), Slic3r::GUI::GizmoObjectManipulation::do_render_move_window(), Slic3r::GUI::GizmoObjectManipulation::do_render_scale_input_window(), Slic3r::GUI::GLGizmoEmboss::draw_advanced(), Slic3r::GUI::GLGizmoSVG::draw_filename(), Slic3r::GUI::GLGizmoEmboss::draw_font_list(), Slic3r::GUI::GLGizmoEmboss::draw_style_list(), Slic3r::GUI::GLGizmoTextureDisplacement::on_render_input_window(), Slic3r::GUI::GLGizmoAssembly::render_assembly_mode_combo(), Slic3r::GUI::GLGizmoBase::render_combo(), and Slic3r::GUI::GLGizmoCut3D::render_cut_mode_combo().

Here is the caller graph for this function:

◆ pop_common_window_style()

void Slic3r::GUI::ImGuiWrapper::pop_common_window_style ( )

static

                                           {
    ImGui::PopStyleColor(14);
    ImGui::PopStyleVar(5);
}

Referenced by Slic3r::GUI::GLCanvas3D::_render_assemble_info(), Slic3r::GUI::DesignSketchTool::draw_dim_label(), Slic3r::GUI::DailyTipsPanel::pop_styles(), Slic3r::GUI::SketchInlineEditor::render(), Slic3r::GUI::GLGizmoMeasure::render_dimensioning(), and Slic3r::GUI::DesignCanvas::render_hud().

Here is the caller graph for this function:

◆ pop_confirm_button_style()

void Slic3r::GUI::ImGuiWrapper::pop_confirm_button_style ( )

static

                                            {
    ImGui::PopStyleColor(6);
}

Referenced by Slic3r::GUI::GLGizmoMeasure::render_dimensioning(), Slic3r::GUI::IMSlider::render_go_to_layer_dialog(), Slic3r::GUI::IMSlider::render_input_custom_gcode(), and Slic3r::GUI::GCodeViewer::SequentialView::Marker::render_position_window().

Here is the caller graph for this function:

◆ pop_font_by_name()

bool Slic3r::GUI::ImGuiWrapper::pop_font_by_name ( std::string font_name )

{
    auto sys_font = im_fonts_map.find(font_name);
    if (sys_font != im_fonts_map.end()) {
        ImGui::PopFont();
        return true;
    }
    return false;
}

References im_fonts_map.

◆ pop_menu_style()

void Slic3r::GUI::ImGuiWrapper::pop_menu_style ( )

static

{
    ImGui::PopStyleColor(4);
    ImGui::PopStyleVar(3);
    ImGuiWrapper::pop_toolbar_style();
}

References pop_toolbar_style().

Referenced by Slic3r::GUI::DailyTipsWindow::render(), Slic3r::GUI::IMSlider::render_go_to_layer_dialog(), Slic3r::GUI::IMSlider::render_input_custom_gcode(), and Slic3r::GUI::IMSlider::render_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ pop_radio_style()

void Slic3r::GUI::ImGuiWrapper::pop_radio_style ( )

static

{
    ImGui::PopStyleColor(2);
    ImGui::PopStyleVar(1);
}

Referenced by Slic3r::GUI::GLGizmoEmboss::draw_model_type(), Slic3r::GUI::GLGizmoSVG::draw_model_type(), and Slic3r::GUI::GLGizmoCut3D::render_connectors_input_window().

Here is the caller graph for this function:

◆ pop_toolbar_style()

void Slic3r::GUI::ImGuiWrapper::pop_toolbar_style ( )

static

{
    // size in push toolbar style
    ImGui::PopStyleColor(16);
    ImGui::PopStyleVar(6);
}

Here is the caller graph for this function:

◆ popup_open()

bool Slic3r::GUI::ImGuiWrapper::popup_open ( ) const

{
    const ImVector<ImGuiPopupData>& stack = ImGui::GetCurrentContext()->OpenPopupStack;
    return std::any_of(stack.begin(), stack.end(), [](const ImGuiPopupData& popup) { return drawn_last_frame(popup.Window); });
}

Referenced by owns_keyboard().

Here is the caller graph for this function:

◆ push_bold_font()

bool Slic3r::GUI::ImGuiWrapper::push_bold_font ( )

                                  {
    if (bold_font) {
        ImGui::PushFont(bold_font);
        return true;
    }
    else {
        return false;
    }
}

References bold_font.

Referenced by Slic3r::GUI::GLCanvas3D::_render_paint_toolbar(), Slic3r::GUI::DailyTipsWindow::render(), Slic3r::GUI::DailyTipsPanel::render_controller_buttons(), and Slic3r::GUI::NotificationManager::SlicingProgressNotification::render_progress_text().

Here is the caller graph for this function:

◆ push_button_disable_style()

void Slic3r::GUI::ImGuiWrapper::push_button_disable_style ( )

static

                                             {
    if (m_is_dark_mode) {
        ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(54 / 255.f, 54 / 255.f, 60 / 255.f, 1.f));
        ImGui::PushStyleColor(ImGuiCol_Border, ImVec4(54 / 255.f, 54 / 255.f, 60 / 255.f, 1.f));
        ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1.f, 1.f, 1.f, 0.4f));
    }
    else {
        ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(206.f / 255.f, 206.f / 255.f, 206.f / 255.f, 1.f));
        ImGui::PushStyleColor(ImGuiCol_Border, ImVec4(206.f / 255.f, 206.f / 255.f, 206.f / 255.f, 1.f));
        ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1.f, 1.f, 1.f, 1.f));
    }
}

References Slic3r::GUI::m_is_dark_mode.

Referenced by Slic3r::GUI::IMSlider::render_go_to_layer_dialog(), and Slic3r::GUI::IMSlider::render_input_custom_gcode().

Here is the caller graph for this function:

◆ push_cancel_button_style()

void Slic3r::GUI::ImGuiWrapper::push_cancel_button_style ( )

static

                                            {
    if (m_is_dark_mode) {
        ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.f, 0.f, 0.f, 0.f));
        ImGui::PushStyleColor(ImGuiCol_Border, ImVec4(1.f, 1.f, 1.f, 0.64f));
        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(73 / 255.f, 73 / 255.f, 78 / 255.f, 1.f));
        ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4(129 / 255.f, 129 / 255.f, 131 / 255.f, 1.f));
        ImGui::PushStyleColor(ImGuiCol_CheckMark, ImVec4(1.f, 1.f, 1.f, 0.64f));
        ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1.f, 1.f, 1.f, 0.64f));
    }
    else {
        ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(1.f, 1.f, 1.f, 1.f));
        ImGui::PushStyleColor(ImGuiCol_Border, ImVec4(38 / 255.f, 46 / 255.f, 48 / 255.f, 1.f));
        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(238.f / 255.f, 238.f / 255.f, 238.f / 255.f, 1.f));
        ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4(206.f / 255.f, 206.f / 255.f, 206.f / 255.f, 1.f));
        ImGui::PushStyleColor(ImGuiCol_CheckMark, ImVec4(0.f, 0.f, 0.f, 1.f));
        ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(38.f / 255.0f, 46.f / 255.0f, 48.f / 255.0f, 1.00f));
    }
}

References Slic3r::GUI::m_is_dark_mode.

Referenced by Slic3r::GUI::GLGizmoMeasure::render_dimensioning(), Slic3r::GUI::IMSlider::render_go_to_layer_dialog(), and Slic3r::GUI::IMSlider::render_input_custom_gcode().

Here is the caller graph for this function:

◆ push_combo_style()

void Slic3r::GUI::ImGuiWrapper::push_combo_style ( const float scale )

static

{
    if (m_is_dark_mode) {
        ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, 1.0f * scale);
        ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 1.0f * scale);
        ImGui::PushStyleColor(ImGuiCol_PopupBg, ImGuiWrapper::COL_WINDOW_BG_DARK);
        ImGui::PushStyleColor(ImGuiCol_BorderActive, ImVec4(0.f, 150.f / 255.f, 136.f / 255.f, 0.6f));  // ORCA hovered item border color
        ImGui::PushStyleColor(ImGuiCol_HeaderHovered, {0.f, 0.f, 0.f, 0.f});                            // ORCA hovered item background color
        ImGui::PushStyleColor(ImGuiCol_HeaderActive, COL_ORCA);
        ImGui::PushStyleColor(ImGuiCol_Header, ImVec4(0.f, 150.f / 255.f, 136.f / 255.f, 0.25f));       // ORCA active item background color
        ImGui::PushStyleColor(ImGuiCol_ScrollbarBg, ImGuiWrapper::COL_WINDOW_BG_DARK);
        ImGui::PushStyleColor(ImGuiCol_Button, {1.00f, 1.00f, 1.00f, 0.0f});
    } else {
        ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, 1.0f * scale);
        ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 1.0f * scale);
        ImGui::PushStyleColor(ImGuiCol_PopupBg, ImGuiWrapper::COL_WINDOW_BG);
        ImGui::PushStyleColor(ImGuiCol_BorderActive, ImVec4(0.f, 150.f / 255.f, 136.f / 255.f, 0.6f));  // ORCA hovered item border color
        ImGui::PushStyleColor(ImGuiCol_HeaderHovered, {0.f, 0.f, 0.f, 0.f});                            // ORCA hovered item background color
        ImGui::PushStyleColor(ImGuiCol_HeaderActive, COL_ORCA);
        ImGui::PushStyleColor(ImGuiCol_Header, ImVec4(0.f, 150.f / 255.f, 136.f / 255.f, 0.25f));       // ORCA active item background color
        ImGui::PushStyleColor(ImGuiCol_ScrollbarBg, ImGuiWrapper::COL_WINDOW_BG);
        ImGui::PushStyleColor(ImGuiCol_Button, {1.00f, 1.00f, 1.00f, 0.0f});
    }
}

References COL_ORCA, COL_WINDOW_BG, COL_WINDOW_BG_DARK, Slic3r::GUI::m_is_dark_mode, and scale().

Referenced by Slic3r::GUI::GLCanvas3D::_render_assemble_control(), Slic3r::GUI::GizmoObjectManipulation::do_render_move_window(), Slic3r::GUI::GizmoObjectManipulation::do_render_scale_input_window(), Slic3r::GUI::GLGizmoEmboss::draw_advanced(), Slic3r::GUI::GLGizmoSVG::draw_filename(), Slic3r::GUI::GLGizmoEmboss::draw_font_list(), Slic3r::GUI::GLGizmoEmboss::draw_style_list(), Slic3r::GUI::GLGizmoTextureDisplacement::on_render_input_window(), Slic3r::GUI::GLGizmoAssembly::render_assembly_mode_combo(), Slic3r::GUI::GLGizmoBase::render_combo(), and Slic3r::GUI::GLGizmoCut3D::render_cut_mode_combo().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ push_common_window_style()

void Slic3r::GUI::ImGuiWrapper::push_common_window_style ( const float scale )

static

                                                             {
    if (m_is_dark_mode) {
        ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 1.0f * scale);
        ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(20.0f, 10.0f) * scale);
        ImGui::PushStyleVar(ImGuiStyleVar_WindowTitleAlign, ImVec2(0.05f, 0.50f) * scale);
        ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 3.0f * scale);
        ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f);
        ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1.0f, 1.0f, 1.0f, 0.88f));                                   // 1
        ImGui::PushStyleColor(ImGuiCol_WindowBg, ImGuiWrapper::COL_WINDOW_BG_DARK);                              // 2
        ImGui::PushStyleColor(ImGuiCol_TitleBg, ImVec4(54 / 255.0f, 54 / 255.0f, 60 / 255.0f, 1.00f));           // 3
        ImGui::PushStyleColor(ImGuiCol_TitleBgActive, ImVec4(54 / 255.0f, 54 / 255.0f, 60 / 255.0f, 1.00f));     // 4
        ImGui::PushStyleColor(ImGuiCol_Separator, ImGuiWrapper::COL_SEPARATOR_DARK);                             // 5
        ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(1.00f, 1.00f, 1.00f, 1.00f));                              // 6
        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(0.00f, 0.59f, 0.53f, 1.00f));                       // 7
        ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4(0.00f, 0.59f, 0.53f, 1.00f));                        // 8
        ImGui::PushStyleColor(ImGuiCol_FrameBgHovered, ImVec4(84 / 255.0f, 84 / 255.0f, 90 / 255.0f, 1.00f));    // 9
        ImGui::PushStyleColor(ImGuiCol_FrameBgActive, ImVec4(62 / 255.0f, 62 / 255.0f, 69 / 255.0f, 1.00f));     // 10
        ImGui::PushStyleColor(ImGuiCol_FrameBg, ImVec4(238 / 255.0f, 238 / 255.0f, 238 / 255.0f, 0.00f));        // 11
        ImGui::PushStyleColor(ImGuiCol_CheckMark, ImVec4(1.00f, 1.00f, 1.00f, 1.00f));                           // 12
        ImGui::PushStyleColor(ImGuiCol_TextSelectedBg, ImVec4(43 / 255.0f, 64 / 255.0f, 54 / 255.0f, 1.00f));    // 13
        ImGui::PushStyleColor(ImGuiCol_PlotHistogram, ImVec4(0.00f, 0.59f, 0.53f, 1.00f));                       // 14
    }
    else {
        ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 1.0f * scale);
        ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(20.0f, 10.0f) * scale);
        ImGui::PushStyleVar(ImGuiStyleVar_WindowTitleAlign, ImVec2(0.05f, 0.50f) * scale);
        ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 3.0f * scale);
        ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f);
        ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(38 / 255.0f, 46 / 255.0f, 48 / 255.0f, 1.00f));              // 1
        ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(1.00f, 1.00f, 1.00f, 1.00f));                            // 2
        ImGui::PushStyleColor(ImGuiCol_TitleBg, ImVec4(245 / 255.0f, 245 / 255.0f, 245 / 255.0f, 1.00f));        // 3
        ImGui::PushStyleColor(ImGuiCol_TitleBgActive, ImVec4(245 / 255.0f, 245 / 255.0f, 245 / 255.0f, 1.00f));  // 4
        ImGui::PushStyleColor(ImGuiCol_Separator, ImGuiWrapper::COL_SEPARATOR);                                  // 5
        ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(1.00f, 1.00f, 1.00f, 1.00f));                              // 6
        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(0.00f, 0.59f, 0.53f, 1.00f));                       // 7
        ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4(0.00f, 0.59f, 0.53f, 1.00f));                        // 8
        ImGui::PushStyleColor(ImGuiCol_FrameBgHovered, ImVec4(238 / 255.0f, 238 / 255.0f, 238 / 255.0f, 1.00f)); // 9
        ImGui::PushStyleColor(ImGuiCol_FrameBgActive, ImVec4(238 / 255.0f, 238 / 255.0f, 238 / 255.0f, 1.00f));  // 10
        ImGui::PushStyleColor(ImGuiCol_FrameBg, ImVec4(238 / 255.0f, 238 / 255.0f, 238 / 255.0f, 0.00f));        // 11
        ImGui::PushStyleColor(ImGuiCol_CheckMark, ImVec4(1.00f, 1.00f, 1.00f, 1.00f));                           // 12
        ImGui::PushStyleColor(ImGuiCol_TextSelectedBg, ImGuiWrapper::COL_GREEN_LIGHT);                           // 13
        ImGui::PushStyleColor(ImGuiCol_PlotHistogram, ImVec4(0.00f, 0.59f, 0.53f, 1.00f));                       // 14
    }
}

References COL_GREEN_LIGHT, COL_SEPARATOR, COL_SEPARATOR_DARK, COL_WINDOW_BG_DARK, Slic3r::GUI::m_is_dark_mode, and scale().

Referenced by Slic3r::GUI::GLCanvas3D::_render_assemble_info(), Slic3r::GUI::DesignSketchTool::draw_dim_label(), Slic3r::GUI::DailyTipsPanel::push_styles(), Slic3r::GUI::SketchInlineEditor::render(), Slic3r::GUI::GLGizmoMeasure::render_dimensioning(), and Slic3r::GUI::DesignCanvas::render_hud().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ push_confirm_button_style()

void Slic3r::GUI::ImGuiWrapper::push_confirm_button_style ( )

static

                                             {
    if (m_is_dark_mode) {
        ImGui::PushStyleColor(ImGuiCol_Button,        to_ImVec4(decode_color_to_float_array("#00675b")));
        ImGui::PushStyleColor(ImGuiCol_Border, ImVec4(0.f / 255.f, 150.f / 255.f, 136.f / 255.f, 1.f));
        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, to_ImVec4(decode_color_to_float_array("#008172")));
        ImGui::PushStyleColor(ImGuiCol_ButtonActive,  to_ImVec4(decode_color_to_float_array("#00675b")));
        ImGui::PushStyleColor(ImGuiCol_CheckMark, ImVec4(1.f, 1.f, 1.f, 0.88f));
        ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1.f, 1.f, 1.f, 0.88f));
    }
    else {
        ImGui::PushStyleColor(ImGuiCol_Button,        to_ImVec4(decode_color_to_float_array("#009688")));
        ImGui::PushStyleColor(ImGuiCol_Border, ImVec4(0.f / 255.f, 150.f / 255.f, 136.f / 255.f, 1.f));
        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, to_ImVec4(decode_color_to_float_array("#26A69A")));
        ImGui::PushStyleColor(ImGuiCol_ButtonActive,  to_ImVec4(decode_color_to_float_array("#009688")));
        ImGui::PushStyleColor(ImGuiCol_CheckMark, ImVec4(1.f, 1.f, 1.f, 1.f));
        ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1.f, 1.f, 1.f, 1.f));
    }
}

References Slic3r::GUI::decode_color_to_float_array(), Slic3r::GUI::m_is_dark_mode, and to_ImVec4().

Referenced by Slic3r::GUI::GLGizmoMeasure::render_dimensioning(), Slic3r::GUI::IMSlider::render_go_to_layer_dialog(), Slic3r::GUI::IMSlider::render_input_custom_gcode(), and Slic3r::GUI::GCodeViewer::SequentialView::Marker::render_position_window().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ push_font_by_name()

bool Slic3r::GUI::ImGuiWrapper::push_font_by_name ( std::string font_name )

{
    auto sys_font = im_fonts_map.find(font_name);
    if (sys_font != im_fonts_map.end()) {
        ImFont* font = sys_font->second;
        if (font && font->ContainerAtlas && font->Glyphs.Size > 4)
            ImGui::PushFont(font);
        else {
            ImGui::PushFont(default_font);
        }
        return true;
    }
    return false;
}

References default_font, and im_fonts_map.

◆ push_menu_style()

void Slic3r::GUI::ImGuiWrapper::push_menu_style ( const float scale )

static

{
    if (m_is_dark_mode) {
        ImGuiWrapper::push_toolbar_style(scale);
        ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(10.0f, 10.0f) * scale);
        ImGui::PushStyleVar(ImGuiStyleVar_PopupRounding, 4.0f * scale);
        ImGui::PushStyleVar(ImGuiStyleVar_PopupBorderSize, 0.0f);
        ImGui::PushStyleColor(ImGuiCol_PopupBg, ImGuiWrapper::COL_WINDOW_BG_DARK);
        ImGui::PushStyleColor(ImGuiCol_Header, ImVec4(0.00f, 0.59f, 0.53f, 1.0f));
        ImGui::PushStyleColor(ImGuiCol_HeaderHovered, ImVec4(0.00f, 0.59f, 0.53f, 1.0f));
        ImGui::PushStyleColor(ImGuiCol_HeaderActive, ImVec4(0.00f, 0.59f, 0.53f, 1.0f));
    }
    else {
        ImGuiWrapper::push_toolbar_style(scale);
        ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(10.0f, 10.0f) * scale);
        ImGui::PushStyleVar(ImGuiStyleVar_PopupRounding, 4.0f * scale);
        ImGui::PushStyleVar(ImGuiStyleVar_PopupBorderSize, 0.0f);
        ImGui::PushStyleColor(ImGuiCol_PopupBg, ImGuiWrapper::COL_WINDOW_BG);
        ImGui::PushStyleColor(ImGuiCol_Header, ImVec4(0.00f, 0.59f, 0.53f, 1.0f));
        ImGui::PushStyleColor(ImGuiCol_HeaderHovered, ImVec4(0.00f, 0.59f, 0.53f, 1.0f));
        ImGui::PushStyleColor(ImGuiCol_HeaderActive, ImVec4(0.00f, 0.59f, 0.53f, 1.0f));
    }
}

References COL_WINDOW_BG, COL_WINDOW_BG_DARK, Slic3r::GUI::m_is_dark_mode, push_toolbar_style(), and scale().

Referenced by Slic3r::GUI::DailyTipsWindow::render(), Slic3r::GUI::IMSlider::render_go_to_layer_dialog(), Slic3r::GUI::IMSlider::render_input_custom_gcode(), and Slic3r::GUI::IMSlider::render_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ push_radio_style()

void Slic3r::GUI::ImGuiWrapper::push_radio_style ( const float scale )

static

{
    ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(1.5f, 1.5f) * scale); // ORCA ensure icon size stays consistent
    if (m_is_dark_mode) {
        ImGui::PushStyleColor(ImGuiCol_CheckMark, to_ImVec4(decode_color_to_float_array("#009688"))); // ORCA use orca color for radio buttons
        ImGui::PushStyleColor(ImGuiCol_Border   , to_ImVec4(decode_color_to_float_array("#949494"))); // ORCA match border color
    } else {
        ImGui::PushStyleColor(ImGuiCol_CheckMark, to_ImVec4(decode_color_to_float_array("#009688"))); // ORCA use orca color for radio buttons
        ImGui::PushStyleColor(ImGuiCol_Border   , to_ImVec4(decode_color_to_float_array("#7C8282"))); // ORCA match border color
    }
}

References Slic3r::GUI::decode_color_to_float_array(), Slic3r::GUI::m_is_dark_mode, scale(), and to_ImVec4().

Referenced by Slic3r::GUI::GLGizmoEmboss::draw_model_type(), Slic3r::GUI::GLGizmoSVG::draw_model_type(), and Slic3r::GUI::GLGizmoCut3D::render_connectors_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ push_toolbar_style()

void Slic3r::GUI::ImGuiWrapper::push_toolbar_style ( const float scale )

static

{
    if (m_is_dark_mode) {
        ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 1.0f * scale);
        ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(20.0f, 10.0f) * scale);
        ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 3.0f * scale);
        ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f);
        ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, 2.0f * scale);
        ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(10.0f, 10.0f) * scale);
        ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1.0f, 1.0f, 1.0f, 0.88f));                                        // 1
        ImGui::PushStyleColor(ImGuiCol_WindowBg, ImGuiWrapper::COL_WINDOW_BG_DARK);                                   // 2
        ImGui::PushStyleColor(ImGuiCol_TitleBg, ImGuiWrapper::COL_TITLE_BG);                                          // 3
        ImGui::PushStyleColor(ImGuiCol_TitleBgActive, ImGuiWrapper::COL_TITLE_BG);                                    // 4
        ImGui::PushStyleColor(ImGuiCol_Separator, ImGuiWrapper::COL_SEPARATOR_DARK);                                  // 5
        ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(62 / 255.0f, 62 / 255.0f, 69 / 255.0f, 1.00f));                 // 6
        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(73 / 255.0f, 73 / 255.0f, 78 / 255.0f, 1.00f));          // 7
        ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4(73 / 255.0f, 73 / 255.0f, 78 / 255.0f, 1.00f));           // 8
        ImGui::PushStyleColor(ImGuiCol_FrameBgHovered, ImVec4(84 / 255.0f, 84 / 255.0f, 90 / 255.0f, 1.00f));         // 9
        ImGui::PushStyleColor(ImGuiCol_FrameBgActive, ImVec4(62 / 255.0f, 62 / 255.0f, 69 / 255.0f, 1.00f));          // 10
        ImGui::PushStyleColor(ImGuiCol_FrameBg, ImVec4(238 / 255.0f, 238 / 255.0f, 238 / 255.0f, 0.00f));             // 11
        ImGui::PushStyleColor(ImGuiCol_TextSelectedBg, ImVec4(43 / 255.0f, 64 / 255.0f, 54 / 255.0f, 1.00f));         // 12
        ImGui::PushStyleColor(ImGuiCol_CheckMark, ImVec4(1.00f, 1.00f, 1.00f, 1.00f));                                // 13
        ImGui::PushStyleColor(ImGuiCol_ScrollbarGrab, ImVec4(0.42f, 0.42f, 0.42f, 1.00f));                            // 14
        ImGui::PushStyleColor(ImGuiCol_ScrollbarGrabHovered, ImVec4(0.93f, 0.93f, 0.93f, 1.00f));                     // 15
        ImGui::PushStyleColor(ImGuiCol_ScrollbarGrabActive, ImVec4(0.93f, 0.93f, 0.93f, 1.00f));                      // 16
    }
    else {
        ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 1.0f * scale);
        ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(20.0f, 10.0f) * scale);
        ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 3.0f * scale);
        ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f);
        ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, 2.0f * scale);
        ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(10.0f, 10.0f) * scale);
        ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(50 / 255.0f, 58 / 255.0f, 61 / 255.0f, 1.00f));       // 1
        ImGui::PushStyleColor(ImGuiCol_WindowBg, ImGuiWrapper::COL_WINDOW_BG);          // 2
        ImGui::PushStyleColor(ImGuiCol_TitleBg, ImGuiWrapper::COL_TITLE_BG);            // 3
        ImGui::PushStyleColor(ImGuiCol_TitleBgActive, ImGuiWrapper::COL_TITLE_BG);      // 4
        ImGui::PushStyleColor(ImGuiCol_Separator, ImGuiWrapper::COL_SEPARATOR);         // 5
        ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(1.00f, 1.00f, 1.00f, 1.00f));     // 6
        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImGuiWrapper::COL_HOVER);         // 7
        ImGui::PushStyleColor(ImGuiCol_FrameBgHovered, ImVec4(238 / 255.0f, 238 / 255.0f, 238 / 255.0f, 1.00f)); // 8
        ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4(172 / 255.0f, 172 / 255.0f, 172 / 255.0f, 1.00f));                        // 9
        ImGui::PushStyleColor(ImGuiCol_FrameBgActive, ImVec4(238 / 255.0f, 238 / 255.0f, 238 / 255.0f, 1.00f));  // 10
        ImGui::PushStyleColor(ImGuiCol_FrameBg, ImVec4(238 / 255.0f, 238 / 255.0f, 238 / 255.0f, 0.00f));        // 11
        ImGui::PushStyleColor(ImGuiCol_TextSelectedBg, COL_GREEN_LIGHT);                                     // 12
        ImGui::PushStyleColor(ImGuiCol_CheckMark, ImVec4(1.00f, 1.00f, 1.00f, 1.00f));//13
        ImGui::PushStyleColor(ImGuiCol_ScrollbarGrab, ImVec4(0.42f, 0.42f, 0.42f, 1.00f));
        ImGui::PushStyleColor(ImGuiCol_ScrollbarGrabHovered, ImVec4(0.93f, 0.93f, 0.93f, 1.00f));
        ImGui::PushStyleColor(ImGuiCol_ScrollbarGrabActive, ImVec4(0.93f, 0.93f, 0.93f, 1.00f));
    }
}

References COL_GREEN_LIGHT, COL_HOVER, COL_SEPARATOR, COL_SEPARATOR_DARK, COL_TITLE_BG, COL_WINDOW_BG, COL_WINDOW_BG_DARK, Slic3r::GUI::m_is_dark_mode, and scale().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ radio_button()

bool Slic3r::GUI::ImGuiWrapper::radio_button	(	const wxString &	label,
		bool	active )

{
    auto label_utf8 = into_u8(label);
    return ImGui::RadioButton(label_utf8.c_str(), active);
}

References Slic3r::GUI::into_u8().

Here is the call graph for this function:

◆ read_glsl_version()

void Slic3r::GUI::ImGuiWrapper::read_glsl_version ( )

References Slic3r::GUI::wxMouseEvent.

◆ render()

void Slic3r::GUI::ImGuiWrapper::render ( ImDrawData * draw_data )

{
    render_draw_data(draw_data);
}

References render_draw_data().

Here is the call graph for this function:

◆ render_draw_data()

void Slic3r::GUI::ImGuiWrapper::render_draw_data ( ImDrawData * draw_data )

private

{
    if (draw_data == nullptr || draw_data->CmdListsCount == 0)
        return;
 
    GLShaderProgram* shader = wxGetApp().get_shader("imgui");
    if (shader == nullptr)
        return;
 
    // Avoid rendering when minimized, scale coordinates for retina displays (screen coordinates != framebuffer coordinates)
    ImGuiIO& io = ImGui::GetIO();
    const int fb_width  = (int)(draw_data->DisplaySize.x * io.DisplayFramebufferScale.x);
    const int fb_height = (int)(draw_data->DisplaySize.y * io.DisplayFramebufferScale.y);
    if (fb_width == 0 || fb_height == 0)
        return;
 
    GLShaderProgram* curr_shader = wxGetApp().get_current_shader();
    if (curr_shader != nullptr)
        curr_shader->stop_using();
 
    shader->start_using();
 
    // Backup GL state
    GLenum last_active_texture;       glsafe(::glGetIntegerv(GL_ACTIVE_TEXTURE, (GLint*)&last_active_texture));
    GLuint last_program;              glsafe(::glGetIntegerv(GL_CURRENT_PROGRAM, (GLint*)&last_program));
    GLuint last_texture;              glsafe(::glGetIntegerv(GL_TEXTURE_BINDING_2D, (GLint*)&last_texture));
    GLuint last_array_buffer;         glsafe(::glGetIntegerv(GL_ARRAY_BUFFER_BINDING, (GLint*)&last_array_buffer));
    GLuint last_vertex_array_object = 0;
#if !SLIC3R_OPENGL_ES
    if (OpenGLManager::get_gl_info().is_core_profile())
#endif // !SLIC3R_OPENGL_ES
        glsafe(::glGetIntegerv(GL_VERTEX_ARRAY_BINDING, (GLint*)&last_vertex_array_object));
    GLint last_viewport[4];           glsafe(::glGetIntegerv(GL_VIEWPORT, last_viewport));
    GLint last_scissor_box[4];        glsafe(::glGetIntegerv(GL_SCISSOR_BOX, last_scissor_box));
    GLenum last_blend_src_rgb;        glsafe(::glGetIntegerv(GL_BLEND_SRC_RGB, (GLint*)&last_blend_src_rgb));
    GLenum last_blend_dst_rgb;        glsafe(::glGetIntegerv(GL_BLEND_DST_RGB, (GLint*)&last_blend_dst_rgb));
    GLenum last_blend_src_alpha;      glsafe(::glGetIntegerv(GL_BLEND_SRC_ALPHA, (GLint*)&last_blend_src_alpha));
    GLenum last_blend_dst_alpha;      glsafe(::glGetIntegerv(GL_BLEND_DST_ALPHA, (GLint*)&last_blend_dst_alpha));
    GLenum last_blend_equation_rgb;   glsafe(::glGetIntegerv(GL_BLEND_EQUATION_RGB, (GLint*)&last_blend_equation_rgb));
    GLenum last_blend_equation_alpha; glsafe(::glGetIntegerv(GL_BLEND_EQUATION_ALPHA, (GLint*)&last_blend_equation_alpha));
    GLboolean last_enable_blend        = ::glIsEnabled(GL_BLEND);
    GLboolean last_enable_cull_face    = ::glIsEnabled(GL_CULL_FACE);
    GLboolean last_enable_depth_test   = ::glIsEnabled(GL_DEPTH_TEST);
    GLboolean last_enable_stencil_test = ::glIsEnabled(GL_STENCIL_TEST);
    GLboolean last_enable_scissor_test = ::glIsEnabled(GL_SCISSOR_TEST);
 
    // set new GL state
    glsafe(::glActiveTexture(GL_TEXTURE0));
    glsafe(::glEnable(GL_BLEND));
    glsafe(::glBlendEquation(GL_FUNC_ADD));
    glsafe(::glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA));
    glsafe(::glDisable(GL_CULL_FACE));
    glsafe(::glDisable(GL_DEPTH_TEST));
    glsafe(::glDisable(GL_STENCIL_TEST));
    glsafe(::glEnable(GL_SCISSOR_TEST));
 
    // Setup viewport, orthographic projection matrix
    // Our visible imgui space lies from draw_data->DisplayPos (top left) to draw_data->DisplayPos+data_data->DisplaySize (bottom right). DisplayPos is (0,0) for single viewport apps.
    glsafe(::glViewport(0, 0, (GLsizei)fb_width, (GLsizei)fb_height));
    const float L = draw_data->DisplayPos.x;
    const float R = draw_data->DisplayPos.x + draw_data->DisplaySize.x;
    const float T = draw_data->DisplayPos.y;
    const float B = draw_data->DisplayPos.y + draw_data->DisplaySize.y;
 
    Matrix4f ortho_projection;
    ortho_projection <<
        2.0f / (R - L), 0.0f,           0.0f,  (R + L) / (L - R),
        0.0f,           2.0f / (T - B), 0.0f,  (T + B) / (B - T),
        0.0f,           0.0f,           -1.0f, 0.0f,
        0.0f,           0.0f,           0.0f,  1.0f;
 
    shader->set_uniform("Texture", 0);
    shader->set_uniform("ProjMtx", ortho_projection);
 
    const uint8_t stage = 0;
    shader->set_uniform("s_texture", stage);
 
    // Will project scissor/clipping rectangles into framebuffer space
    const ImVec2 clip_off   = draw_data->DisplayPos;       // (0,0) unless using multi-viewports
    const ImVec2 clip_scale = draw_data->FramebufferScale; // (1,1) unless using retina display which are often (2,2)
 
    // Render command lists
    for (int n = 0; n < draw_data->CmdListsCount; ++n) {
        const ImDrawList* cmd_list = draw_data->CmdLists[n];
        const ImDrawVert* vtx_buffer = cmd_list->VtxBuffer.Data;
        const ImDrawIdx* idx_buffer  = cmd_list->IdxBuffer.Data;
        const GLsizeiptr vtx_buffer_size = (GLsizeiptr)cmd_list->VtxBuffer.Size * (int)sizeof(ImDrawVert);
        const GLsizeiptr idx_buffer_size = (GLsizeiptr)cmd_list->IdxBuffer.Size * (int)sizeof(ImDrawIdx);
 
        GLuint vao_id = 0;
#if !SLIC3R_OPENGL_ES
        if (OpenGLManager::get_gl_info().is_core_profile()) {
#endif // !SLIC3R_OPENGL_ES
            glsafe(::glGenVertexArrays(1, &vao_id));
            glsafe(::glBindVertexArray(vao_id));
#if !SLIC3R_OPENGL_ES
        }
#endif // !SLIC3R_OPENGL_ES
 
        GLuint vbo_id;
        glsafe(::glGenBuffers(1, &vbo_id));
        glsafe(::glBindBuffer(GL_ARRAY_BUFFER, vbo_id));
        glsafe(::glBufferData(GL_ARRAY_BUFFER, vtx_buffer_size, vtx_buffer, GL_STATIC_DRAW));
 
        GLuint ibo_id;
        glsafe(::glGenBuffers(1, &ibo_id));
        glsafe(::glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo_id));
        glsafe(::glBufferData(GL_ELEMENT_ARRAY_BUFFER, idx_buffer_size, idx_buffer, GL_STATIC_DRAW));
 
        const int position_id = shader->get_attrib_location("Position");
        if (position_id != -1) {
            glsafe(::glVertexAttribPointer(position_id, 2, GL_FLOAT, GL_FALSE, sizeof(ImDrawVert), (const void*)IM_OFFSETOF(ImDrawVert, pos)));
            glsafe(::glEnableVertexAttribArray(position_id));
        }
        const int uv_id = shader->get_attrib_location("UV");
        if (uv_id != -1) {
            glsafe(::glVertexAttribPointer(uv_id, 2, GL_FLOAT, GL_FALSE, sizeof(ImDrawVert), (const void*)IM_OFFSETOF(ImDrawVert, uv)));
            glsafe(::glEnableVertexAttribArray(uv_id));
        }
        const int color_id = shader->get_attrib_location("Color");
        if (color_id != -1) {
            glsafe(::glVertexAttribPointer(color_id, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(ImDrawVert), (const void*)IM_OFFSETOF(ImDrawVert, col)));
            glsafe(::glEnableVertexAttribArray(color_id));
        }
 
        for (int cmd_i = 0; cmd_i < cmd_list->CmdBuffer.Size; ++cmd_i) {
            const ImDrawCmd* pcmd = &cmd_list->CmdBuffer[cmd_i];
            if (pcmd->UserCallback)
                // User callback (registered via ImDrawList::AddCallback)
                pcmd->UserCallback(cmd_list, pcmd);
            else {
                // Project scissor/clipping rectangles into framebuffer space
                const ImVec2 clip_min((pcmd->ClipRect.x - clip_off.x) * clip_scale.x, (pcmd->ClipRect.y - clip_off.y) * clip_scale.y);
                const ImVec2 clip_max((pcmd->ClipRect.z - clip_off.x) * clip_scale.x, (pcmd->ClipRect.w - clip_off.y) * clip_scale.y);
                if (clip_max.x <= clip_min.x || clip_max.y <= clip_min.y)
                    continue;
 
                // Apply scissor/clipping rectangle (Y is inverted in OpenGL)
                glsafe(::glScissor((int)clip_min.x, (int)(fb_height - clip_max.y), (int)(clip_max.x - clip_min.x), (int)(clip_max.y - clip_min.y)));
 
                // Bind texture, Draw
                glsafe(::glActiveTexture(GL_TEXTURE0 + stage));
                glsafe(::glBindTexture(GL_TEXTURE_2D, (GLuint)(intptr_t)pcmd->GetTexID()));
                glsafe(::glDrawElements(GL_TRIANGLES, (GLsizei)pcmd->ElemCount, sizeof(ImDrawIdx) == 2 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT, (void*)(intptr_t)(pcmd->IdxOffset * sizeof(ImDrawIdx))));
            }
        }
 
        if (position_id != -1)
            glsafe(::glDisableVertexAttribArray(position_id));
        if (uv_id != -1)
            glsafe(::glDisableVertexAttribArray(uv_id));
        if (color_id != -1)
            glsafe(::glDisableVertexAttribArray(color_id));
 
        glsafe(::glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0));
        glsafe(::glBindBuffer(GL_ARRAY_BUFFER, 0));
 
        glsafe(::glDeleteBuffers(1, &ibo_id));
        glsafe(::glDeleteBuffers(1, &vbo_id));
#if !SLIC3R_OPENGL_ES
        if (OpenGLManager::get_gl_info().is_core_profile()) {
#endif // !SLIC3R_OPENGL_ES
            if (vao_id > 0)
                glsafe(::glDeleteVertexArrays(1, &vao_id));
#if !SLIC3R_OPENGL_ES
        }
#endif // !SLIC3R_OPENGL_ES
    }
 
    // Restore modified GL state
    glsafe(::glBindTexture(GL_TEXTURE_2D, last_texture));
    glsafe(::glActiveTexture(last_active_texture));
#if !SLIC3R_OPENGL_ES
    if (OpenGLManager::get_gl_info().is_core_profile())
#endif // !SLIC3R_OPENGL_ES
        glsafe(::glBindVertexArray(last_vertex_array_object));
    glsafe(::glBindBuffer(GL_ARRAY_BUFFER, last_array_buffer));
    glsafe(::glBlendEquationSeparate(last_blend_equation_rgb, last_blend_equation_alpha));
    glsafe(::glBlendFuncSeparate(last_blend_src_rgb, last_blend_dst_rgb, last_blend_src_alpha, last_blend_dst_alpha));
    if (last_enable_blend) glsafe(::glEnable(GL_BLEND)); else glsafe(::glDisable(GL_BLEND));
    if (last_enable_cull_face) glsafe(::glEnable(GL_CULL_FACE)); else glsafe(::glDisable(GL_CULL_FACE));
    if (last_enable_depth_test) glsafe(::glEnable(GL_DEPTH_TEST)); else glsafe(::glDisable(GL_DEPTH_TEST));
    if (last_enable_stencil_test) glsafe(::glEnable(GL_STENCIL_TEST)); else glsafe(::glDisable(GL_STENCIL_TEST));
    if (last_enable_scissor_test) glsafe(::glEnable(GL_SCISSOR_TEST)); else glsafe(::glDisable(GL_SCISSOR_TEST));
    glsafe(::glViewport(last_viewport[0], last_viewport[1], (GLsizei)last_viewport[2], (GLsizei)last_viewport[3]));
    glsafe(::glScissor(last_scissor_box[0], last_scissor_box[1], (GLsizei)last_scissor_box[2], (GLsizei)last_scissor_box[3]));
 
    shader->stop_using();
 
    if (curr_shader != nullptr)
        curr_shader->start_using();
}

References Slic3r::GLShaderProgram::get_attrib_location(), Slic3r::GUI::OpenGLManager::get_gl_info(), GL_ACTIVE_TEXTURE, GL_ARRAY_BUFFER, GL_ARRAY_BUFFER_BINDING, GL_BLEND, GL_BLEND_DST_ALPHA, GL_BLEND_DST_RGB, GL_BLEND_EQUATION_ALPHA, GL_BLEND_EQUATION_RGB, GL_BLEND_SRC_ALPHA, GL_BLEND_SRC_RGB, GL_CULL_FACE, GL_CURRENT_PROGRAM, GL_DEPTH_TEST, GL_ELEMENT_ARRAY_BUFFER, GL_FALSE, GL_FLOAT, GL_FUNC_ADD, GL_ONE, GL_ONE_MINUS_SRC_ALPHA, GL_SCISSOR_BOX, GL_SCISSOR_TEST, GL_SRC_ALPHA, GL_STATIC_DRAW, GL_STENCIL_TEST, GL_TEXTURE0, GL_TEXTURE_2D, GL_TEXTURE_BINDING_2D, GL_TRIANGLES, GL_TRUE, GL_UNSIGNED_BYTE, GL_UNSIGNED_INT, GL_UNSIGNED_SHORT, GL_VERTEX_ARRAY_BINDING, GL_VIEWPORT, glActiveTexture, glBindBuffer, glBindTexture, glBindVertexArray, glBlendEquation, glBlendEquationSeparate, glBlendFuncSeparate, glBufferData, glDeleteBuffers, glDeleteVertexArrays, glDisable, glDisableVertexAttribArray, glDrawElements, glEnable, glEnableVertexAttribArray, glGenBuffers, glGenVertexArrays, glGetIntegerv, glIsEnabled, glsafe, glScissor, glVertexAttribPointer, glViewport, L, Slic3r::GLShaderProgram::set_uniform(), Slic3r::GLShaderProgram::start_using(), and Slic3r::GLShaderProgram::stop_using().

Referenced by render().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ request_frames_while_held()

void Slic3r::GUI::ImGuiWrapper::request_frames_while_held ( )

inline

    {
        if (ImGui::IsItemActive() && ImGui::IsMouseDown(ImGuiMouseButton_Left))
            set_requires_extra_frame();
    }

References set_requires_extra_frame().

Here is the call graph for this function:

◆ requires_extra_frame()

bool Slic3r::GUI::ImGuiWrapper::requires_extra_frame ( ) const

inline

364{ return m_requires_extra_frame; }

◆ reset_requires_extra_frame()

void Slic3r::GUI::ImGuiWrapper::reset_requires_extra_frame ( )

inline

366{ m_requires_extra_frame = false; }

◆ scaled() [1/2]

float Slic3r::GUI::ImGuiWrapper::scaled ( float x ) const

inline

119{ return x * m_font_size; }

References m_font_size.

Referenced by Slic3r::GUI::GLCanvas3D::_render_arrange_menu(), Slic3r::GUI::GLCanvas3D::_render_canvas_toolbar(), Slic3r::GUI::GLCanvas3D::_render_imex_ghost_tooltip(), Slic3r::GUI::GLCanvas3D::_render_return_toolbar(), Slic3r::GUI::GLCanvas3D::_render_section_view_panel(), Slic3r::GUI::GizmoObjectManipulation::do_render_move_window(), Slic3r::GUI::GizmoObjectManipulation::do_render_scale_input_window(), Slic3r::GUI::GCodeViewer::render_all_plates_stats(), Slic3r::GUI::Mouse3DController::render_settings_dialog(), and Slic3r::GUI::GLCanvas3D::LayersEditing::render_variable_layer_height_dialog().

Here is the caller graph for this function:

◆ scaled() [2/2]

ImVec2 Slic3r::GUI::ImGuiWrapper::scaled	(	float	x,
		float	y ) const

inline

120{ return ImVec2(x * m_font_size, y * m_font_size); }

References m_font_size.

◆ search_list()

void Slic3r::GUI::ImGuiWrapper::search_list	(	const ImVec2 &	size,
		bool(*	items_getter )(int, const char label, const char tooltip),
		char *	search_str,
		Search::OptionViewParameters &	view_params,
		int &	selected,
		bool &	edited,
		int &	mouse_wheel,
		bool	is_localized )

{
    int& hovered_id = view_params.hovered_id;
    // ImGui::ListBoxHeader("", size);
    {
        // rewrote part of function to add a TextInput instead of label Text
        ImGuiContext& g = *GImGui;
        ImGuiWindow* window = ImGui::GetCurrentWindow();
        if (window->SkipItems)
            return ;
 
        const ImGuiStyle& style = g.Style;
 
        // Size default to hold ~7 items. Fractional number of items helps seeing that we can scroll down/up without looking at scrollbar.
        ImVec2 size = ImGui::CalcItemSize(size_, ImGui::CalcItemWidth(), ImGui::GetTextLineHeightWithSpacing() * 7.4f + style.ItemSpacing.y);
        ImRect frame_bb(window->DC.CursorPos, ImVec2(window->DC.CursorPos.x + size.x, window->DC.CursorPos.y + size.y));
 
        ImRect bb(frame_bb.Min, frame_bb.Max);
        window->DC.LastItemRect = bb; // Forward storage for ListBoxFooter.. dodgy.
        g.NextItemData.ClearFlags();
 
        if (!ImGui::IsRectVisible(bb.Min, bb.Max))
        {
            ImGui::ItemSize(bb.GetSize(), style.FramePadding.y);
            ImGui::ItemAdd(bb, 0, &frame_bb);
            return ;
        }
 
        ImGui::BeginGroup();
 
        const ImGuiID id = ImGui::GetID(search_str);
        ImVec2 search_size = ImVec2(size.x, ImGui::GetTextLineHeightWithSpacing() + style.ItemSpacing.y);
 
        if (!ImGui::IsAnyItemFocused() && !ImGui::IsAnyItemActive() && !ImGui::IsMouseClicked(0))
            ImGui::SetKeyboardFocusHere(0);
 
        // The press on Esc key invokes editing of InputText (removes last changes)
        // So we should save previous value...
        std::string str = search_str;
        ImGui::InputTextEx("", NULL, search_str, 40, search_size, ImGuiInputTextFlags_AutoSelectAll, NULL, NULL);
        edited = ImGui::IsItemEdited();
        if (edited)
            hovered_id = 0;
 
        process_key_down(ImGuiKey_Escape, [&selected, search_str, str]() {
            // use 9999 to mark selection as a Esc key
            selected = 9999;
            // ... and when Esc key was pressed, than revert search_str value
            strcpy(search_str, str.c_str());
        });
 
        ImGui::BeginChildFrame(id, frame_bb.GetSize());
    }
 
    int i = 0;
    const char* item_text;
    const char* tooltip;
    int mouse_hovered = -1;
 
    while (items_getter(i, &item_text, &tooltip))
    {
        selectable(item_text, i == hovered_id);
 
        if (ImGui::IsItemHovered()) {
            ImGui::SetTooltip("%s", /*item_text*/tooltip);
                hovered_id = -1;
            mouse_hovered = i;
        }
 
        if (ImGui::IsItemClicked())
            selected = i;
        i++;
    }
 
    // Process mouse wheel
    if (mouse_hovered > 0)
        process_mouse_wheel(mouse_wheel);
 
    // process Up/DownArrows and Enter
    process_key_down(ImGuiKey_UpArrow, [&hovered_id, mouse_hovered]() {
        if (mouse_hovered > 0)
            scroll_up();
        else {
            if (hovered_id > 0)
                --hovered_id;
            scroll_y(hovered_id);
        }
    });
 
    process_key_down(ImGuiKey_DownArrow, [&hovered_id, mouse_hovered, i]() {
        if (mouse_hovered > 0)
            scroll_down();
        else {
            if (hovered_id < 0)
                hovered_id = 0;
            else if (hovered_id < i - 1)
                ++hovered_id;
            scroll_y(hovered_id);
        }
    });
 
    process_key_down(ImGuiKey_Enter, [&selected, hovered_id]() {
        selected = hovered_id;
    });
 
    ImGui::ListBoxFooter();
 
    auto check_box = [&edited, this](const wxString& label, bool& check) {
        ImGui::SameLine();
        bool ch = check;
        checkbox(label, ch);
        if (ImGui::IsItemClicked()) {
            check = !check;
            edited = true;
        }
    };
 
    ImGui::AlignTextToFramePadding();
 
    // add checkboxes for show/hide Categories and Groups
    //text(_L("Use for search")+":");
    //check_box(_L("Category"),   view_params.category);
    //if (is_localized)
    //    check_box(_L("Search in English"), view_params.english);
}

References checkbox(), Slic3r::Search::OptionViewParameters::hovered_id, ImRect, Slic3r::GUI::process_key_down(), Slic3r::GUI::process_mouse_wheel(), Slic3r::GUI::scroll_down(), Slic3r::GUI::scroll_up(), Slic3r::GUI::scroll_y(), Slic3r::GUI::selectable(), style, and tooltip().

Here is the call graph for this function:

◆ set_display_size()

void Slic3r::GUI::ImGuiWrapper::set_display_size	(	float	w,
		float	h )

{
    ImGuiIO& io = ImGui::GetIO();
    io.DisplaySize = ImVec2(w, h);
    io.DisplayFramebufferScale = ImVec2(1.0f, 1.0f);
}

◆ set_language()

void Slic3r::GUI::ImGuiWrapper::set_language ( const std::string & language )

{
    if (m_new_frame_open) {
        // ImGUI internally locks the font between NewFrame() and EndFrame()
        // NewFrame() might've been called here because of input from the 3D scene;
        // call EndFrame()
        ImGui::EndFrame();
        m_new_frame_open = false;
    }
 
    const ImWchar *ranges = nullptr;
    size_t idx = language.find('_');
    std::string lang = (idx == std::string::npos) ? language : language.substr(0, idx);
    static const ImWchar ranges_latin2[] =
    {
        0x0020, 0x00FF, // Basic Latin + Latin Supplement
        0x0100, 0x017F, // Latin Extended-A
        0,
    };
    static const ImWchar ranges_turkish[] = {
        0x0020, 0x01FF, // Basic Latin + Latin Supplement
        0x0100, 0x017F, // Latin Extended-A
        0x0180, 0x01FF, // Turkish
        0,
    };
    static const ImWchar ranges_vietnamese[] =
    {
        0x0020, 0x00FF, // Basic Latin
        0x0102, 0x0103,
        0x0110, 0x0111,
        0x0128, 0x0129,
        0x0168, 0x0169,
        0x01A0, 0x01A1,
        0x01AF, 0x01B0,
        0x1EA0, 0x1EF9,
        0,
    };
    m_font_cjk = false;
    m_is_korean = false;
    if (lang == "cs" || lang == "pl") {
        ranges = ranges_latin2;
    } else if (lang == "ru" || lang == "uk") {
        ranges = ImGui::GetIO().Fonts->GetGlyphRangesCyrillic(); // Default + about 400 Cyrillic characters
    } else if (lang == "tr") {
        ranges = ranges_turkish;
    } else if (lang == "vi") {
        ranges = ranges_vietnamese;
    } else if (lang == "ja") {
        ranges = ImGui::GetIO().Fonts->GetGlyphRangesJapanese(); // Default + Hiragana, Katakana, Half-Width, Selection of 1946 Ideographs
        m_font_cjk = true;
    } else if (lang == "ko") {
        ranges = ImGui::GetIO().Fonts->GetGlyphRangesKorean(); // Default + Korean characters
        m_font_cjk = true;
        m_is_korean = true;
    } else if (lang == "zh") {
        ranges = (language == "zh_TW") ?
            // Traditional Chinese
            // Default + Half-Width + Japanese Hiragana/Katakana + full set of about 21000 CJK Unified Ideographs
            ImGui::GetIO().Fonts->GetGlyphRangesChineseFull() :
            // Simplified Chinese
            // Default + Half-Width + Japanese Hiragana/Katakana + set of 2500 CJK Unified Ideographs for common simplified Chinese
            ImGui::GetIO().Fonts->GetGlyphRangesChineseSimplifiedCommon();
        m_font_cjk = true;
    } else if (lang == "th") {
        ranges = ImGui::GetIO().Fonts->GetGlyphRangesThai(); // Default + Thai characters
    }
    else if (lang == "en") {
        ranges = ImGui::GetIO().Fonts->GetGlyphRangesEnglish(); // Basic Latin
    }
    else{
        ranges = ImGui::GetIO().Fonts->GetGlyphRangesOthers();
    }
 
    if (ranges != m_glyph_ranges) {
        m_glyph_ranges = ranges;
        //destroy_fonts_texture();
        destroy_font();
    }
 
    m_glyph_basic_ranges = ImGui::GetIO().Fonts->GetGlyphRangesBasic();
}

References destroy_font(), m_font_cjk, m_glyph_basic_ranges, m_glyph_ranges, m_is_korean, and m_new_frame_open.

Here is the call graph for this function:

◆ set_next_window_bg_alpha()

void Slic3r::GUI::ImGuiWrapper::set_next_window_bg_alpha ( float alpha )

{
    ImGui::SetNextWindowBgAlpha(alpha);
}

Referenced by Slic3r::GUI::DesignSketchTool::draw_dim_label().

Here is the caller graph for this function:

◆ set_next_window_pos()

void Slic3r::GUI::ImGuiWrapper::set_next_window_pos	(	float	x,
		float	y,
		int	flag,
		float	pivot_x = 0.0f,
		float	pivot_y = 0.0f )

{
    ImGui::SetNextWindowPos(ImVec2(x, y), (ImGuiCond)flag, ImVec2(pivot_x, pivot_y));
    ImGui::SetNextWindowSize(ImVec2(0.0, 0.0));
}

Here is the caller graph for this function:

◆ set_next_window_size()

void Slic3r::GUI::ImGuiWrapper::set_next_window_size	(	float	x,
		float	y,
		ImGuiCond	cond )

{
    ImGui::SetNextWindowSize(ImVec2(x, y), cond);
}

Referenced by Slic3r::GUI::GLCanvas3D::_render_imgui_select_plate_toolbar(), Slic3r::GUI::GLCanvas3D::_render_plate_switcher(), Slic3r::GUI::GLCanvas3D::_render_return_toolbar(), Slic3r::GUI::NotificationManager::PopNotification::bbl_render_block_notification(), and Slic3r::GUI::NotificationManager::PopNotification::render().

Here is the caller graph for this function:

◆ set_requires_extra_frame()

void Slic3r::GUI::ImGuiWrapper::set_requires_extra_frame ( )

inline

365{ m_requires_extra_frame = true; }

Referenced by Slic3r::GUI::GLCanvas3D::_render_paint_toolbar(), Slic3r::GUI::IMSlider::on_mouse_wheel(), Slic3r::GUI::GLCanvas3D::Labels::render(), Slic3r::GUI::GLCanvas3D::Tooltip::render(), Slic3r::GUI::GLCanvas3D::CenterOfMass::render_details(), Slic3r::GUI::GCodeViewer::SequentialView::Marker::render_position_window(), and request_frames_while_held().

Here is the caller graph for this function:

◆ set_scaling()

void Slic3r::GUI::ImGuiWrapper::set_scaling	(	float	font_size,
		float	scale_style,
		float	scale_both )

{
    font_size *= scale_both;
    scale_style *= scale_both;
 
    if (m_font_size == font_size && m_style_scaling == scale_style) {
        return;
    }
 
    m_font_size = font_size;
 
    ImGui::GetStyle().ScaleAllSizes(scale_style / m_style_scaling);
    m_style_scaling = scale_style;
 
    //destroy_fonts_texture();
    destroy_font();
}

References destroy_font(), m_font_size, and m_style_scaling.

Here is the call graph for this function:

◆ slider_float() [1/3]

bool Slic3r::GUI::ImGuiWrapper::slider_float	(	const char *	label,
		float *	v,
		float	v_min,
		float	v_max,
		const char *	format = "%.3f",
		float	power = 1.0f,
		bool	clamp = true )

{
    bool ret = ImGui::SliderFloat(label, v, v_min, v_max, format, power);
    if (clamp)
        *v = std::clamp(*v, v_min, v_max);
    return ret;
}

References Slic3r::GUI::format().

Referenced by Slic3r::GUI::GCodeViewer::render_overlay(), Slic3r::GUI::GCodeViewer::render_toolpaths(), slider_float(), slider_float(), slider_optional_float(), and slider_optional_int().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ slider_float() [2/3]

bool Slic3r::GUI::ImGuiWrapper::slider_float	(	const std::string &	label,
		float *	v,
		float	v_min,
		float	v_max,
		const char *	format = "%.3f",
		float	power = 1.0f,
		bool	clamp = true )

{
    return this->slider_float(label.c_str(), v, v_min, v_max, format, power, clamp);
}

References Slic3r::GUI::format(), and slider_float().

Here is the call graph for this function:

◆ slider_float() [3/3]

bool Slic3r::GUI::ImGuiWrapper::slider_float	(	const wxString &	label,
		float *	v,
		float	v_min,
		float	v_max,
		const char *	format = "%.3f",
		float	power = 1.0f,
		bool	clamp = true )

{
    auto label_utf8 = into_u8(label);
    return this->slider_float(label_utf8.c_str(), v, v_min, v_max, format, power, clamp);
}

References Slic3r::GUI::format(), Slic3r::GUI::into_u8(), and slider_float().

Here is the call graph for this function:

◆ slider_optional_float()

bool Slic3r::GUI::ImGuiWrapper::slider_optional_float	(	const char *	label,
		std::optional< float > &	v,
		float	v_min,
		float	v_max,
		const char *	format = "%.3f",
		float	power = 1.0f,
		bool	clamp = true,
		const wxString &	tooltip = {},
		bool	show_edit_btn = true,
		float	def_val = .0f )

{
    auto func = [&](float &value) {
        return slider_float(label, &value, v_min, v_max, format, power, clamp, tooltip, show_edit_btn);
    };
    std::function<bool(const float &)> is_default =
        [def_val](const float &value) -> bool {
        return std::fabs(value - def_val) <= std::numeric_limits<float>::epsilon();
    };
    return input_optional(v, func, is_default, def_val);
}

References Slic3r::GUI::format(), Slic3r::GUI::input_optional(), slider_float(), and tooltip().

Here is the call graph for this function:

◆ slider_optional_int()

bool Slic3r::GUI::ImGuiWrapper::slider_optional_int	(	const char *	label,
		std::optional< int > &	v,
		int	v_min,
		int	v_max,
		const char *	format = "%.3f",
		float	power = 1.0f,
		bool	clamp = true,
		const wxString &	tooltip = {},
		bool	show_edit_btn = true,
		int	def_val = 0 )

{
    std::optional<float> val;
    if (v.has_value()) val = static_cast<float>(*v);
    auto func = [&](float &value) {
        return slider_float(label, &value, v_min, v_max, format, power, clamp, tooltip, show_edit_btn);
    };
    std::function<bool(const float &)> is_default =
        [def_val](const float &value) -> bool {
        return std::fabs(value - def_val) < 0.9f;
    };
 
    float default_value = static_cast<float>(def_val);
    if (input_optional(val, func, is_default, default_value)) {
        if (val.has_value())
            v = static_cast<int>(std::round(*val));
        else
            v.reset(); 
        return true;
    } else return false;
}

References Slic3r::GUI::format(), Slic3r::GUI::input_optional(), slider_float(), and tooltip().

Here is the call graph for this function:

◆ sub_title()

void Slic3r::GUI::ImGuiWrapper::sub_title ( const std::string & label )

{
    ImDrawList *draw_list = ImGui::GetWindowDrawList();
    text_colored(ImVec4(1.0f, 1.0f, 1.0f, 0.5f), label);
    ImGui::SameLine();
    ImVec2 cursor_pos = ImGui::GetCursorScreenPos();
    float available_width = ImGui::GetContentRegionAvail().x;
    draw_list->AddLine(ImVec2(cursor_pos.x, cursor_pos.y + 8.0f), ImVec2(cursor_pos.x + available_width, cursor_pos.y + 8.0f), IM_COL32(255, 255, 255, 100));
    ImGui::NewLine();
}

References text_colored().

Here is the call graph for this function:

◆ suggest_location()

ImVec2 Slic3r::GUI::ImGuiWrapper::suggest_location	(	const ImVec2 &	dialog_size,
		const Slic3r::Polygon &	interest,
		const ImVec2 &	canvas_size )

static

Suggest loacation of dialog window, dependent on actual visible thing on platter like Gizmo menu size, notifications, ... To be near of polygon interest and not over it. And also not out of visible area.

Parameters

dialog_size	Define width and height of diaog window
interest	Area of interest. Result should be close to it
canvas_size	Available space a.k.a GLCanvas3D::get_current_canvas3D()

Returns: Suggestion for dialog offest

{
    // IMPROVE 1: do not select place over menu
    // BoundingBox top_menu;
    // GLGizmosManager &gizmo_mng = canvas->get_gizmos_manager();
    // BoundingBox      side_menu; // gizmo_mng.get_size();
    // BoundingBox left_bottom_menu; // is permanent?
    // NotificationManager *notify_mng = plater->get_notification_manager();
    // BoundingBox          notifications; // notify_mng->get_size();
    // m_window_width, m_window_height + position
 
    // IMPROVE 2: use polygon of interest not only bounding box
    BoundingBox bb(interest.points);
    Point       center = bb.center(); // interest.centroid();
 
    // area size
    Point window_center(canvas_size.x / 2, canvas_size.y / 2);
 
    // mov on side
    Point bb_half_size = (bb.max - bb.min) / 2 + Point(1,1);
    Point diff_center  = window_center - center;
    Vec2d diff_norm(diff_center.x() / (double) bb_half_size.x(),
                    diff_center.y() / (double) bb_half_size.y());
    if (diff_norm.x() > 1.) diff_norm.x() = 1.;
    if (diff_norm.x() < -1.) diff_norm.x() = -1.;
    if (diff_norm.y() > 1.) diff_norm.y() = 1.;
    if (diff_norm.y() < -1.) diff_norm.y() = -1.;
 
    Vec2d abs_diff(abs(diff_norm.x()), abs(diff_norm.y()));
    if (abs_diff.x() < 1. && abs_diff.y() < 1.) {
        if (abs_diff.x() > abs_diff.y())
            diff_norm.x() = (diff_norm.x() < 0.) ? (-1.) : 1.;
        else
            diff_norm.y() = (diff_norm.y() < 0.) ? (-1.) : 1.;
    }
 
    Point half_dialog_size(dialog_size.x / 2., dialog_size.y / 2.);
    Point move_size       = bb_half_size + half_dialog_size;
    Point offseted_center = center - half_dialog_size;
    Vec2d offset(offseted_center.x() + diff_norm.x() * move_size.x(),
                 offseted_center.y() + diff_norm.y() * move_size.y());
 
    // move offset close to center
    Points window_polygon = {offset.cast<coord_t>(),
                             Point(offset.x(), offset.y() + dialog_size.y),
                             Point(offset.x() + dialog_size.x,
                                   offset.y() + dialog_size.y),
                             Point(offset.x() + dialog_size.x, offset.y())};
    // check that position by Bounding box is not intersecting
    assert(Slic3r::intersection(interest, Polygon(window_polygon)).empty());
 
    double allowed_space = 10; // in px
    double allowed_space_sq = allowed_space * allowed_space;
    Vec2d  move_vec         = (center - (offset.cast<coord_t>() + half_dialog_size))
                         .cast<double>();    
    Vec2d result_move(0, 0);
    do {
        move_vec             = move_vec / 2.;
        Point  move_point    = (move_vec + result_move).cast<coord_t>();
        Points moved_polygon = window_polygon; // copy
        for (Point &p : moved_polygon) p += move_point;
        if (Slic3r::intersection(interest, Polygon(moved_polygon)).empty())
            result_move += move_vec;
        
    } while (move_vec.squaredNorm() >= allowed_space_sq);
    offset += result_move;
 
    return ImVec2(offset.x(), offset.y());
}

References Slic3r::cast(), Slic3r::BoundingBoxBase< PointType, APointsType >::center(), Slic3r::center(), Slic3r::empty(), Slic3r::intersection(), Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBoxBase< PointType, APointsType >::min, Slic3r::offset(), and Slic3r::MultiPoint::points.

Referenced by anonymous_namespace{GLGizmoEmboss.cpp}::calc_fine_position().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ text() [1/3]

void Slic3r::GUI::ImGuiWrapper::text ( const char * label )

static

{
    ImGui::Text("%s", label);
}

◆ text() [2/3]

void Slic3r::GUI::ImGuiWrapper::text ( const std::string & label )

static

{
    ImGuiWrapper::text(label.c_str());
}

References text().

Here is the call graph for this function:

◆ text() [3/3]

void Slic3r::GUI::ImGuiWrapper::text ( const wxString & label )

static

{
    auto label_utf8 = into_u8(label);
    ImGuiWrapper::text(label_utf8.c_str());
}

References Slic3r::GUI::into_u8(), and text().

Here is the call graph for this function:

◆ text_colored() [1/3]

void Slic3r::GUI::ImGuiWrapper::text_colored	(	const ImVec4 &	color,
		const char *	label )

static

{
    ImGui::TextColored(color, "%s", label);
}

Here is the caller graph for this function:

◆ text_colored() [2/3]

void Slic3r::GUI::ImGuiWrapper::text_colored	(	const ImVec4 &	color,
		const std::string &	label )

static

{
    ImGuiWrapper::text_colored(color, label.c_str());
}

References text_colored().

Here is the call graph for this function:

◆ text_colored() [3/3]

void Slic3r::GUI::ImGuiWrapper::text_colored	(	const ImVec4 &	color,
		const wxString &	label )

static

{
    auto label_utf8 = into_u8(label);
    ImGuiWrapper::text_colored(color, label_utf8.c_str());
}

References Slic3r::GUI::into_u8(), and text_colored().

Here is the call graph for this function:

◆ text_input_active()

bool Slic3r::GUI::ImGuiWrapper::text_input_active ( ) const

{
    // An active InputText requests text input in each frame that draws it, and NewFrame() moves the
    // request into io.WantTextInput.
    const ImGuiContext& g = *ImGui::GetCurrentContext();
    return g.WithinFrameScope ? g.IO.WantTextInput : g.WantTextInputNextFrame == 1;
}

Referenced by owns_key(), and owns_keyboard().

Here is the caller graph for this function:

◆ text_wrapped() [1/3]

void Slic3r::GUI::ImGuiWrapper::text_wrapped	(	const char *	label,
		float	wrap_width )

{
    ImGui::PushTextWrapPos(ImGui::GetCursorPos().x + wrap_width);
    this->text(label);
    ImGui::PopTextWrapPos();
}

References text().

Referenced by Slic3r::GUI::GCodeViewer::render_legend_color_arr_recommen(), Slic3r::GUI::DailyTipsDataRenderer::render_text(), text_wrapped(), and text_wrapped().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ text_wrapped() [2/3]

void Slic3r::GUI::ImGuiWrapper::text_wrapped	(	const std::string &	label,
		float	wrap_width )

{
    this->text_wrapped(label.c_str(), wrap_width);
}

References text_wrapped().

Here is the call graph for this function:

◆ text_wrapped() [3/3]

void Slic3r::GUI::ImGuiWrapper::text_wrapped	(	const wxString &	label,
		float	wrap_width )

{
    auto label_utf8 = into_u8(label);
    this->text_wrapped(label_utf8.c_str(), wrap_width);
}

References Slic3r::GUI::into_u8(), and text_wrapped().

Here is the call graph for this function:

◆ title() [1/2]

void Slic3r::GUI::ImGuiWrapper::title ( const std::string & str )

{
    if (bold_font){
        ImGui::PushFont(bold_font);
        text(str);
        ImGui::PopFont();
    } else {
        text(str);
    }
    ImGui::Separator();
}

References bold_font, and text().

Referenced by Slic3r::GUI::GCodeViewer::render_all_plates_stats().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ title() [2/2]

void Slic3r::GUI::ImGuiWrapper::title	(	const std::string &	str,
		bool	suppress_seperator )

{
    if (bold_font) {
        ImGui::PushFont(bold_font);
        text(str);
        ImGui::PopFont();
    } else {
        text(str);
    }
    if (!suppress_seperator)    {
      ImGui::Separator();
    }
}

References bold_font, and text().

Here is the call graph for this function:

◆ to_ImU32()

ImU32 Slic3r::GUI::ImGuiWrapper::to_ImU32 ( const ColorRGBA & color )

static

{
    return ImGui::GetColorU32({ color.r(), color.g(), color.b(), color.a() });
}

References Slic3r::ColorRGBA::a(), Slic3r::ColorRGBA::b(), Slic3r::ColorRGBA::g(), and Slic3r::ColorRGBA::r().

Referenced by Slic3r::GUI::add_swatch(), Slic3r::GUI::GLGizmoMmuSegmentation::draw_color_button(), Slic3r::GUI::IMSlider::draw_colored_band(), Slic3r::GUI::DesignSketchTool::draw_dim_label(), Slic3r::GUI::IMSlider::render_add_menu(), Slic3r::GUI::GLGizmoCut3D::render_cut_plane_input_window(), Slic3r::GUI::GLGizmoMeasure::render_dimensioning(), Slic3r::GUI::IMSlider::render_edit_menu(), Slic3r::GUI::render_extruders_combo(), and Slic3r::GUI::GCodeViewer::render_legend().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ to_ImVec4() [1/2]

ImVec4 Slic3r::GUI::ImGuiWrapper::to_ImVec4 ( const ColorRGB & color )

static

                                                    {
    return {color.r(), color.g(), color.b(), 1.0};
}

References Slic3r::ColorRGB::b(), Slic3r::ColorRGB::g(), and Slic3r::ColorRGB::r().

Referenced by Slic3r::GUI::NotificationManager::PopNotification::PopNotification(), Slic3r::GUI::GLCanvas3D::_render_3d_navigator(), Slic3r::GUI::GLCanvas3D::_render_paint_toolbar(), Slic3r::GUI::GizmoObjectManipulation::do_render_move_window(), Slic3r::GUI::GizmoObjectManipulation::do_render_rotate_window(), Slic3r::GUI::GizmoObjectManipulation::do_render_scale_input_window(), Slic3r::GUI::GLGizmoMmuSegmentation::draw_color_button(), init_style(), Slic3r::GLVolume::load_render_colors(), Slic3r::GUI::Bed3D::load_render_colors(), Slic3r::GUI::GLCanvas3D::load_render_colors(), Slic3r::GUI::GLGizmoBase::load_render_colors(), Slic3r::GUI::PartPlate::load_render_colors(), push_confirm_button_style(), push_radio_style(), Slic3r::GUI::SketchInlineEditor::render(), Slic3r::GUI::GCodeViewer::SequentialView::Marker::render_position_window(), Slic3r::GUI::GLGizmoMeasure::show_distance_xyz_ui(), and Slic3r::GUI::GLGizmoMeasure::show_selection_ui().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ to_ImVec4() [2/2]

ImVec4 Slic3r::GUI::ImGuiWrapper::to_ImVec4 ( const ColorRGBA & color )

static

{
    return { color.r(), color.g(), color.b(), color.a() };
}

References Slic3r::ColorRGBA::a(), Slic3r::ColorRGBA::b(), Slic3r::ColorRGBA::g(), and Slic3r::ColorRGBA::r().

Here is the call graph for this function:

◆ tooltip() [1/3]

void Slic3r::GUI::ImGuiWrapper::tooltip	(	const char *	label,
		float	wrap_width )

{
    ImGui::BeginTooltip();
    ImGui::PushTextWrapPos(wrap_width);
    ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1.00f, 1.00f, 1.00f, 1.00f));
    ImGui::TextUnformatted(label);
    ImGui::PopStyleColor(1);
    ImGui::PopTextWrapPos();
    ImGui::EndTooltip();
}

Referenced by Slic3r::GUI::GLCanvas3D::_render_canvas_toolbar(), Slic3r::GUI::GLCanvas3D::_render_paint_toolbar(), Slic3r::GUI::GLCanvas3D::_render_plate_switcher(), bbl_button(), bbl_slider_float(), bbl_slider_float_style(), button(), Slic3r::GUI::GizmoObjectManipulation::do_render_move_window(), Slic3r::GUI::GizmoObjectManipulation::do_render_rotate_window(), Slic3r::GUI::GizmoObjectManipulation::do_render_scale_input_window(), image_button(), search_list(), slider_optional_float(), slider_optional_int(), and tooltip().

Here is the caller graph for this function:

◆ tooltip() [2/3]

void Slic3r::GUI::ImGuiWrapper::tooltip	(	const std::string &	label,
		float	wrap_width )

                                                                   {
    tooltip(label.c_str(), wrap_width);
}

References tooltip().

Here is the call graph for this function:

◆ tooltip() [3/3]

void Slic3r::GUI::ImGuiWrapper::tooltip	(	const wxString &	label,
		float	wrap_width )

{
    ImGui::BeginTooltip();
    ImGui::PushTextWrapPos(wrap_width);
    ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1.00f, 1.00f, 1.00f, 1.00f));
    ImGui::TextUnformatted(label.ToUTF8().data());
    ImGui::PopStyleColor(1);
    ImGui::PopTextWrapPos();
    ImGui::EndTooltip();
}

◆ trunc()

std::string Slic3r::GUI::ImGuiWrapper::trunc	(	const std::string &	text,
		float	width,
		const char *	tail = " .." )

static

Truncate text by ImGui draw function to specific width NOTE 1: ImGui must be initialized NOTE 2: Calculation for actual acive imgui font.

Parameters

text	Text to be truncated
width	Maximal width before truncate
tail	String puted on end of text to be visible truncation

Returns: Truncated text

{
    float text_width = ImGui::CalcTextSize(text.c_str()).x;
    if (text_width < width) return text;
    float tail_width = ImGui::CalcTextSize(tail).x;
    assert(width > tail_width);
    if (width <= tail_width) return "Error: Can't add tail and not be under wanted width.";
    float allowed_width = width - tail_width;
    
    // guess approx count of letter
    float average_letter_width = calc_text_size(std::string_view("n")).x; // average letter width
    unsigned count_letter  = static_cast<unsigned>(allowed_width / average_letter_width);
 
    std::string_view text_ = text;
    std::string_view result_text = text_.substr(0, count_letter);
    text_width = calc_text_size(result_text).x;
    if (text_width < allowed_width) {
        // increase letter count
        while (count_letter < text.length()) {
            ++count_letter;
            std::string_view act_text = text_.substr(0, count_letter);
            text_width = calc_text_size(act_text).x;
            if (text_width > allowed_width) break;
            result_text = act_text;
        }
    } else {
        // decrease letter count
        while (count_letter > 1) {
            --count_letter;
            result_text = text_.substr(0, count_letter);
            text_width  = calc_text_size(result_text).x;
            if (text_width < allowed_width) break;            
        } 
    }
    return std::string(result_text) + tail;
}

References calc_text_size(), and text().

Referenced by Slic3r::GUI::GLGizmoSVG::draw_filename(), Slic3r::GUI::GLGizmoEmboss::draw_style_list(), Slic3r::GUI::Emboss::StyleManager::init_trunc_names(), and anonymous_namespace{GLGizmoEmboss.cpp}::init_truncated_names().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ undo_redo_list()

bool Slic3r::GUI::ImGuiWrapper::undo_redo_list	(	const ImVec2 &	size,
		const bool	is_undo,
		bool(*	items_getter )(const bool, int, const char **),
		int &	hovered,
		int &	selected,
		int &	mouse_wheel )

{
    bool is_hovered = false;
    ImGui::ListBoxHeader("", size);
 
    int i=0;
    const char* item_text;
    while (items_getter(is_undo, i, &item_text)) {
        ImGui::Selectable(item_text, i < hovered);
 
        if (ImGui::IsItemHovered()) {
            ImGui::SetTooltip("%s", item_text);
            hovered = i;
            is_hovered = true;
        }
 
        if (ImGui::IsItemClicked())
            selected = i;
        i++;
    }
 
    if (is_hovered)
        process_mouse_wheel(mouse_wheel);
 
    ImGui::ListBoxFooter();
    return is_hovered;
}

References Slic3r::GUI::process_mouse_wheel().

Here is the call graph for this function:

◆ update_key_data()

bool Slic3r::GUI::ImGuiWrapper::update_key_data ( wxKeyEvent & evt )

{
    if (! display_initialized()) {
        return false;
    }
 
    ImGuiIO& io = ImGui::GetIO();
 
    if (evt.GetEventType() == wxEVT_CHAR) {
        // Char event
        const auto key = evt.GetUnicodeKey();
        // THE MEASUREMENT THAT CANNOT LIE. This is the ONLY place in the application where ImGui
        // is ever handed a character, so an ImGui text field that stays empty while reporting
        // itself active has exactly two possible causes, and this line separates them: no output
        // at all means the wxEVT_CHAR never reached the GL canvas (a focus problem, upstream of
        // ImGui entirely), while output with unicode=0 means the character arrived empty and is
        // being dropped right here.
        //
        // It lives here rather than on the canvas because a probe bound on the canvas CANNOT
        // answer this: GLCanvas3D::on_char is bound later than any constructor-time probe, wx
        // runs handlers in reverse bind order, and on_char returns without Skip() whenever this
        // function returns true — so such a probe stays silent whether or not the key arrived.
        // A day was lost to reading that silence as evidence.
        if (std::getenv("ORCA_CAD_UXTRACE")) {
            fprintf(stderr, "[UX] imgui_char unicode=%d keycode=%d want_text=%d\n",
                    (int) key, evt.GetKeyCode(), (int) io.WantTextInput);
            fflush(stderr);
        }
        if (key != 0) {
            io.AddInputCharacter(key);
        }
    } else {
        // Key up/down event
        int key = evt.GetKeyCode();
        wxCHECK_MSG(key >= 0 && key < IM_ARRAYSIZE(io.KeysDown), false, "Received invalid key code");
 
        io.KeysDown[key] = evt.GetEventType() == wxEVT_KEY_DOWN;
        io.KeyShift = evt.ShiftDown();
        io.KeyCtrl = evt.ControlDown();
        io.KeyAlt = evt.AltDown();
        io.KeySuper = evt.MetaDown();
    }
    bool ret = want_keyboard() || want_text_input();
    if (ret)
        new_frame();
    return ret;
}

References display_initialized(), new_frame(), want_keyboard(), and want_text_input().

Here is the call graph for this function:

◆ update_mouse_data()

bool Slic3r::GUI::ImGuiWrapper::update_mouse_data ( wxMouseEvent & evt )

{
    if (! display_initialized()) {
        return false;
    }
 
    ImGuiIO& io = ImGui::GetIO();
    io.MousePos = ImVec2((float)evt.GetX(), (float)evt.GetY());
    io.MouseDown[0] = evt.LeftIsDown();
    io.MouseDown[1] = evt.RightIsDown();
    io.MouseDown[2] = evt.MiddleIsDown();
    // Replaces a modifier left held when its key-up was sent to another window.
    io.KeyCtrl  = evt.ControlDown();
    io.KeyShift = evt.ShiftDown();
    io.KeyAlt   = evt.AltDown();
    io.KeySuper = evt.MetaDown();
    // Only a vertical wheel event with a direction is a wheel step. A macOS trackpad reports sideways motion
    // as separate horizontal events, and its wheel events often carry a rotation of 0: wx truncates the
    // sub-pixel deltas to whole ones and passes on events with no delta at all. Read as vertical steps,
    // either kind scrolls against the gesture, and scrolling up bounces back and forth.
    if (evt.GetWheelAxis() == wxMOUSE_WHEEL_VERTICAL && evt.GetWheelRotation() != 0)
        io.MouseWheel = evt.GetWheelRotation() > 0 ? 1.f : -1.f;
    unsigned buttons = (evt.LeftIsDown() ? 1 : 0) | (evt.RightIsDown() ? 2 : 0) | (evt.MiddleIsDown() ? 4 : 0);
    m_mouse_buttons = buttons;
 
    if (want_mouse())
        new_frame();
    return want_mouse();
}

References display_initialized(), m_mouse_buttons, new_frame(), want_mouse(), and Slic3r::GUI::wxMouseEvent.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ want_any_input()

bool Slic3r::GUI::ImGuiWrapper::want_any_input ( ) const

{
    const auto io = ImGui::GetIO();
    return io.WantCaptureMouse || io.WantCaptureKeyboard || io.WantTextInput;
}

◆ want_keyboard()

bool Slic3r::GUI::ImGuiWrapper::want_keyboard ( ) const

{
    return ImGui::GetIO().WantCaptureKeyboard;
}

Referenced by update_key_data().

Here is the caller graph for this function:

◆ want_mouse()

bool Slic3r::GUI::ImGuiWrapper::want_mouse ( ) const

{
    return ImGui::GetIO().WantCaptureMouse;
}

Referenced by update_mouse_data().

Here is the caller graph for this function:

◆ want_text_input()

bool Slic3r::GUI::ImGuiWrapper::want_text_input ( ) const

{
    return ImGui::GetIO().WantTextInput;
}

Referenced by update_key_data().

Here is the caller graph for this function:

◆ warning_text() [1/2]

void Slic3r::GUI::ImGuiWrapper::warning_text ( const char * all_text )

{
    ImGui::PushStyleColor(ImGuiCol_Text, ImGuiWrapper::COL_WARNING);
    this->text(label);
    ImGui::PopStyleColor();
}

References COL_WARNING, and text().

Here is the call graph for this function:

◆ warning_text() [2/2]

void Slic3r::GUI::ImGuiWrapper::warning_text ( const wxString & all_text )

{
    auto label_utf8 = into_u8(all_text);
    warning_text(label_utf8.c_str());
}

References Slic3r::GUI::into_u8(), and Slic3r::GUI::warning_text.

Here is the call graph for this function:

Member Data Documentation

◆ bold_font

ImFont* Slic3r::GUI::ImGuiWrapper::bold_font = nullptr

private

Referenced by bold_text(), init_font(), pop_bold_font(), push_bold_font(), title(), and title().

◆ COL_ACTIVE

const ImVec4 Slic3r::GUI::ImGuiWrapper::COL_ACTIVE = { 0.675f, 0.675f, 0.675f, 1.0f }

static

Referenced by Slic3r::GUI::GLCanvas3D::_render_assembly_tooltip_button(), init_style(), and Slic3r::GUI::GLGizmoUtils::render_tooltip_button().

◆ COL_BLUE

const ImVec4 Slic3r::GUI::ImGuiWrapper::COL_BLUE = ImVec4(0.0f, 0.0f, 1.0f, 1.0f)

static

◆ COL_BLUE_LIGHT

const ImVec4 Slic3r::GUI::ImGuiWrapper::COL_BLUE_LIGHT = ImVec4(0.122f, 0.557f, 0.918f, 1.0f)

static

Referenced by init_style().

◆ COL_BUTTON_ACTIVE

const ImVec4 Slic3r::GUI::ImGuiWrapper::COL_BUTTON_ACTIVE = COL_BUTTON_HOVERED

static

Referenced by Slic3r::GUI::GCodeViewer::SequentialView::Marker::render_position_window().

◆ COL_BUTTON_BACKGROUND

const ImVec4 Slic3r::GUI::ImGuiWrapper::COL_BUTTON_BACKGROUND = COL_ORANGE_DARK

static

Referenced by init_style(), and Slic3r::GUI::GCodeViewer::SequentialView::Marker::render_position_window().

◆ COL_BUTTON_HOVERED

const ImVec4 Slic3r::GUI::ImGuiWrapper::COL_BUTTON_HOVERED = COL_ORANGE_LIGHT

static

Referenced by Slic3r::GUI::GCodeViewer::SequentialView::Marker::render_position_window().

bool Slic3r::GUI::ImGuiWrapper::m_disabled { false }

private

70{ false };

Referenced by disabled_begin(), and disabled_end().

std::vector<std::string> Slic3r::GUI::ImGuiWrapper::m_fonts_names

private

Referenced by get_fonts_names().

◆ m_glyph_basic_ranges

const ImWchar* Slic3r::GUI::ImGuiWrapper::m_glyph_basic_ranges { nullptr }

private

61{ nullptr };

Referenced by set_language().

◆ m_glyph_ranges

const ImWchar* Slic3r::GUI::ImGuiWrapper::m_glyph_ranges { nullptr }

private

60{ nullptr };

Referenced by get_glyph_ranges(), init_font(), and set_language().

◆ m_is_korean

bool Slic3r::GUI::ImGuiWrapper::m_is_korean { false }

private

64{ false };

Referenced by set_language().

◆ m_key_claims

std::map<int, bool> Slic3r::GUI::ImGuiWrapper::m_key_claims

private

Referenced by claim_key_event(), and forget_key_claims().

◆ m_last_frame_time

std::chrono::steady_clock::time_point Slic3r::GUI::ImGuiWrapper::m_last_frame_time {}

private

73{};

Referenced by new_frame().

int Slic3r::GUI::ImGuiWrapper::TOOLBAR_WINDOW_FLAGS

static

Initial value:

= ImGuiWindowFlags_AlwaysAutoResize
                                 | ImGuiWindowFlags_NoMove
                                 | ImGuiWindowFlags_NoResize
                                 | ImGuiWindowFlags_NoCollapse
                                 | ImGuiWindowFlags_NoTitleBar

Referenced by Slic3r::GUI::GizmoObjectManipulation::do_render_move_window(), Slic3r::GUI::GizmoObjectManipulation::do_render_rotate_window(), and Slic3r::GUI::GizmoObjectManipulation::do_render_scale_input_window().

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

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

	OrcaSlicer latest OrcaSlicer

Classes

Public Member Functions

Static Public Member Functions

Static Public Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ImGuiWrapper()

◆ ~ImGuiWrapper()

Member Function Documentation

◆ bbl_button()

◆ bbl_checkbox()

◆ bbl_combo_with_filter()

◆ bbl_input_double()

◆ bbl_radio_button()

◆ bbl_slider_float()

◆ bbl_slider_float_style()

◆ bbl_sliderin()

◆ begin() [1/4]

◆ begin() [2/4]

◆ begin() [3/4]

◆ begin() [4/4]

◆ bold_text()

◆ button() [1/3]

◆ button() [2/3]

◆ button() [3/3]

◆ calc_button_size()

◆ calc_text_size() [1/3]

◆ calc_text_size() [2/3]

◆ calc_text_size() [3/3]

◆ calculate_filament_group_text_size()

◆ change_window_position()

◆ checkbox()

◆ claim_key_event()

◆ clipboard_get()

◆ clipboard_set()

◆ close_top_popup()

◆ combo() [1/2]

◆ combo() [2/2]

◆ contain_all_glyphs()

◆ destroy_font()

◆ destroy_fonts_texture()

◆ disable_background_fadeout_animation()

◆ disabled_begin()

◆ disabled_end()

◆ display_initialized()

◆ drag_optional_float()

◆ draw()

◆ draw_cross_hair()

◆ draw_data_signature()

◆ draw_gradient_ramp()

◆ end()

◆ end_frame()

◆ escape_double_hash()

◆ filament_group()

◆ find_widest_text()

◆ forget_key_claims()

◆ from_ImU32()

◆ from_ImVec4()

◆ get_font_size()

◆ get_fonts_names()

◆ get_glyph_ranges()

◆ get_item_spacing()

◆ get_last_slider_status() [1/2]

◆ get_last_slider_status() [2/2]

◆ get_slider_float_height()

◆ get_style_scaling()

◆ GetTextureCustomRect()

◆ glyph_button()

◆ image_button() [1/2]

◆ image_button() [2/2]

◆ init_font()

◆ init_input()

◆ init_style()

◆ input_double() [1/2]

◆ input_double() [2/2]

◆ input_optional_float()

◆ input_optional_int()