Slic3r::GUI::GCodeViewer::SequentialView::Marker Class Reference

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

Collaboration diagram for Slic3r::GUI::GCodeViewer::SequentialView::Marker:

Public Member Functions
void	init (std::string filename)
const BoundingBoxf3 &	get_bounding_box () const
void	set_world_position (const Vec3f &position)
void	set_world_offset (const Vec3f &offset)
void	set_z_offset (float z_offset)
void	set_high_precision_gcode (bool high_precision)
bool	is_visible () const
void	set_visible (bool visible)
void	set_color (const ColorRGBA &color)
void	render (int canvas_width, int canvas_height, const libvgcode::EViewType &view_type)
void	render_position_window (const libvgcode::Viewer *viewer, int canvas_width, int canvas_height, const libvgcode::EViewType &view_type)
void	on_change_color_mode (bool is_dark)

Static Public Member Functions
static ColorRGBA	default_color ()

Public Attributes
float	m_scale = 1.0f

Private Attributes
GLModel	m_model
Vec3f	m_world_position
Vec3f	m_world_offset
float	m_z_offset { 0.0f }
float	m_model_z_offset { 0.5f }
bool	m_visible { true }
bool	m_is_dark = false
bool	m_high_precision_gcode { false }
float	m_scale_factor { 1.0f }

Detailed Description

Member Function Documentation

default_color()

ColorRGBA Slic3r::GUI::GCodeViewer::SequentialView::Marker::default_color ( )

inlinestatic

{ return { 1.0f, 1.0f, 1.0f, 0.5f }; }

Referenced by init(), and Slic3r::GUI::GCodeViewer::render_markers().

Here is the caller graph for this function:

get_bounding_box()

const BoundingBoxf3 & Slic3r::GUI::GCodeViewer::SequentialView::Marker::get_bounding_box ( ) const

inline

{ return m_model.get_bounding_box(); }

References m_model.

init()

void Slic3r::GUI::GCodeViewer::SequentialView::Marker::init

(

std::string

filename

)

{
    if (filename.empty()) {
        m_model.init_from(stilized_arrow(16, 1.5f, 3.0f, 0.8f, 3.0f));
    } else {
        m_model.init_from_file(filename);
    }
    m_model.set_color(default_color());
}

References default_color(), m_model, and Slic3r::GUI::stilized_arrow().

Here is the call graph for this function:

is_visible()

bool Slic3r::GUI::GCodeViewer::SequentialView::Marker::is_visible ( ) const

inline

{ return m_visible; }

References m_visible.

on_change_color_mode()

void Slic3r::GUI::GCodeViewer::SequentialView::Marker::on_change_color_mode ( bool is_dark )

inline

{ m_is_dark = is_dark; }

References is_dark(), and m_is_dark.

Here is the call graph for this function:

render()

void Slic3r::GUI::GCodeViewer::SequentialView::Marker::render	(	int	canvas_width,
		int	canvas_height,
		const libvgcode::EViewType &	view_type )

{
    if (!m_visible)
        return;
 
    GLShaderProgram* shader = wxGetApp().get_shader("gouraud_light");
    if (shader == nullptr)
        return;
 
    glsafe(::glEnable(GL_BLEND));
    glsafe(::glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA));
 
    shader->start_using();
    shader->set_uniform("emission_factor", 0.0f);
 
    const Camera& camera = wxGetApp().plater()->get_camera();
    const Transform3d& view_matrix = camera.get_view_matrix();
    float scale_factor = m_scale_factor;
    const Transform3d model_matrix = (Geometry::translation_transform((m_world_position + m_model_z_offset * Vec3f::UnitZ()).cast<double>()) *
        Geometry::translation_transform(scale_factor * m_model.get_bounding_box().size().z() * Vec3d::UnitZ()) * Geometry::rotation_transform({ M_PI, 0.0, 0.0 })) *
        Geometry::scale_transform(scale_factor);
    shader->set_uniform("view_model_matrix", view_matrix * model_matrix);
    shader->set_uniform("projection_matrix", camera.get_projection_matrix());
    const Matrix3d view_normal_matrix = view_matrix.matrix().block(0, 0, 3, 3) * model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose();
    shader->set_uniform("view_normal_matrix", view_normal_matrix);
 
    m_model.render();
 
    shader->stop_using();
 
    glsafe(::glDisable(GL_BLEND));
}

References Slic3r::cast(), Slic3r::GUI::Camera::get_projection_matrix(), Slic3r::GUI::Camera::get_view_matrix(), GL_BLEND, GL_ONE_MINUS_SRC_ALPHA, GL_SRC_ALPHA, glBlendFunc, glDisable, glEnable, glsafe, m_model, m_model_z_offset, M_PI, m_scale_factor, m_visible, m_world_position, Slic3r::Geometry::rotation_transform(), Slic3r::Geometry::scale_transform(), Slic3r::GLShaderProgram::set_uniform(), Slic3r::GLShaderProgram::start_using(), Slic3r::GLShaderProgram::stop_using(), and Slic3r::Geometry::translation_transform().

Here is the call graph for this function:

render_position_window()

void Slic3r::GUI::GCodeViewer::SequentialView::Marker::render_position_window	(	const libvgcode::Viewer *	viewer,
		int	canvas_width,
		int	canvas_height,
		const libvgcode::EViewType &	view_type )

{
    static bool properties_shown = false;
    
    const std::string NA_TXT = _u8L("N/A");
    const char* NA_CSTR = NA_TXT.c_str();
 
    if (viewer != nullptr) {
        ImGuiWrapper& imgui = *wxGetApp().imgui();
        // const Size cnv_size = wxGetApp().plater()->get_current_canvas3D()->get_canvas_size();
        imgui.set_next_window_pos(0.5f * static_cast<float>(canvas_width), static_cast<float>(canvas_height), ImGuiCond_Always, 0.5f, 1.0f);
        ImGui::PushStyleColor(ImGuiCol_Button, ImGuiWrapper::COL_BUTTON_BACKGROUND);
        ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImGuiWrapper::COL_BUTTON_ACTIVE);
        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImGuiWrapper::COL_BUTTON_HOVERED);
        ImGui::PushStyleColor(ImGuiCol_Border   , ImVec4(.0f,.0f,.0f,.0f));
        ImGui::PushStyleColor(ImGuiCol_Separator, ImVec4(1.f,1.f,1.f,.6f));
        ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 8.0f * m_scale);
        ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding , ImVec2(10.f, 10.f) * m_scale);
        ImGui::SetNextWindowBgAlpha(0.8f);
 
        libvgcode::PathVertex vertex = viewer->get_current_vertex();
        size_t vertex_id = viewer->get_current_vertex_id();
        // Seam moves may contain non-deterministic vertex data, so use the
        // last visible non-seam vertex instead (except in FeatureType view)
        if (view_type != libvgcode::EViewType::FeatureType && vertex.type == libvgcode::EMoveType::Seam) {
            const libvgcode::Interval& visible_range = viewer->get_view_visible_range();
            if (visible_range[1] > 0) {
                vertex_id = static_cast<size_t>(visible_range[1]) - 1;
                vertex = viewer->get_vertex_at(vertex_id);
            }
        }
        const bool is_extrusion = vertex.is_extrusion();
 
        const ImGuiStyle& style = ImGui::GetStyle();
 
        char detail_buf[1024];
        switch (view_type) {
            case libvgcode::EViewType::FeatureType:
                if (is_extrusion)
                    strcpy(detail_buf, to_string(vertex.role).c_str());
                else if (vertex.type != libvgcode::EMoveType::Noop)
                    strcpy(detail_buf, to_string(vertex.type).c_str());
                else
                    strcpy(detail_buf, NA_CSTR); // Noop moves are not shown in the "Line type" view, so show N/A for them.
                break;
            case libvgcode::EViewType::Height:
                if (is_extrusion)
                    sprintf(detail_buf, "%s%.2f", _u8L("Height: ").c_str(), vertex.height);
                else
                    sprintf(detail_buf, "%s%s", _u8L("Height: ").c_str(), NA_CSTR);
                break;
            case libvgcode::EViewType::Width:
                if (is_extrusion)
                    sprintf(detail_buf, "%s%.2f", _u8L("Width: ").c_str(), vertex.width);
                else
                    sprintf(detail_buf, "%s%s", _u8L("Width: ").c_str(), NA_CSTR);
                break;
            case libvgcode::EViewType::VolumetricFlowRate:
                if (is_extrusion)
                    sprintf(detail_buf, "%s%.2f", _u8L("Flow: ").c_str(), vertex.volumetric_rate());
                else
                    sprintf(detail_buf, "%s%s", _u8L("Flow: ").c_str(), NA_CSTR);
                break;
            case libvgcode::EViewType::FanSpeed:
                sprintf(detail_buf, "%s%.0f", _u8L("Fan: ").c_str(), vertex.fan_speed);
                break;
            case libvgcode::EViewType::Temperature:
                sprintf(detail_buf, "%s%.0f", _u8L("Temperature: ").c_str(), vertex.temperature);
                break;
            case libvgcode::EViewType::LayerTimeLinear:
            case libvgcode::EViewType::LayerTimeLogarithmic:
                sprintf(detail_buf, "%s%.1f", _u8L("Layer Time: ").c_str(), vertex.layer_duration);
                break;
            case libvgcode::EViewType::Tool:
                sprintf(detail_buf, "%s%d", _u8L("Tool: ").c_str(), vertex.extruder_id + 1);
                break;
            case libvgcode::EViewType::ColorPrint:
                sprintf(detail_buf, "%s%d", _u8L("Color: ").c_str(), vertex.color_id + 1);
                break;
            case libvgcode::EViewType::Acceleration:
                sprintf(detail_buf, "%s%.0f", _u8L("Acceleration: ").c_str(), vertex.acceleration);
                break;
            case libvgcode::EViewType::Jerk:
                sprintf(detail_buf, "%s%.1f", _u8L("Jerk: ").c_str(), vertex.jerk);
                break;
            case libvgcode::EViewType::PressureAdvance:
                sprintf(detail_buf, "%s%.4f", _u8L("PA: ").c_str(), vertex.pressure_advance);
                break;
            default:
                detail_buf[0] = '\0';
                break;
        }
 
        std::vector<std::pair<std::string, std::string>> properties_rows;
        float table_content_w = 0.0f;
        if (properties_shown) {
            float label_w = 0.0f;
            float value_w = 0.0f;
            properties_rows.reserve(14);
            auto add_row = [&properties_rows, &label_w, &value_w](std::string label, std::string value) {
                 label_w = std::max(label_w, ImGui::CalcTextSize(label.c_str()).x);
                 value_w = std::max(value_w, ImGui::CalcTextSize(value.c_str()).x);
                 properties_rows.emplace_back(std::move(label), std::move(value));
            };
            char buff[1024];
            add_row(_u8L("Type"), _u8L(to_string(vertex.type)));
            add_row(_u8L("Line Type"), is_extrusion ? _u8L(to_string(vertex.role)) : NA_TXT);
            if (is_extrusion) sprintf(buff, ("%.3f " + _u8L("mm")).c_str(), vertex.width); else strcpy(buff, NA_CSTR);
            add_row(_u8L("Width"), buff);
            if (is_extrusion) sprintf(buff, ("%.3f " + _u8L("mm")).c_str(), vertex.height); else strcpy(buff, NA_CSTR);
            add_row(_u8L("Height"), buff);
            // ORCA: Length of the move ending at the current vertex. Arc moves (G2/G3) are discretized
            // into several vertices sharing the same gcode line id, so accumulate the whole run to report
            // the arc length instead of the length of a single chord.
            if (vertex_id > 0 && (is_extrusion || vertex.is_travel() || vertex.is_wipe())) {
                const size_t vertices_count = viewer->get_vertices_count();
                size_t first_id = vertex_id;
                while (first_id > 0 && viewer->get_vertex_at(first_id - 1).gcode_id == vertex.gcode_id)
                    --first_id;
                size_t last_id = vertex_id;
                while (last_id + 1 < vertices_count && viewer->get_vertex_at(last_id + 1).gcode_id == vertex.gcode_id)
                    ++last_id;
                float length = 0.0f;
                for (size_t i = std::max<size_t>(first_id, 1); i <= last_id; ++i) {
                    length += (libvgcode::convert(viewer->get_vertex_at(i).position) -
                               libvgcode::convert(viewer->get_vertex_at(i - 1).position)).norm();
                }
                sprintf(buff, ("%.3f " + _u8L("mm")).c_str(), length);
            }
            else
                strcpy(buff, NA_CSTR);
            add_row(_u8L("Length"), buff);
            sprintf(buff, "%d", vertex.layer_id + 1);
            add_row(_u8L("Layer"), buff);
            sprintf(buff, ("%.1f " + _u8L("mm/s")).c_str(), vertex.feedrate);
            add_row(_u8L("Speed"), buff);
            sprintf(buff, ("%.0f " + _u8L("mm/s²")).c_str(), vertex.acceleration);
            add_row(_u8L("Acceleration"), buff);
            sprintf(buff, ("%.1f " + _u8L("mm/s")).c_str(), vertex.jerk);
            add_row(_u8L("Jerk"), buff);
            if (is_extrusion) sprintf(buff, ("%.3f " + _u8L("mm³/s")).c_str(), vertex.volumetric_rate()); else strcpy(buff, NA_CSTR);
            add_row(_u8L("Flow rate"), buff);
            sprintf(buff, "%.0f %%", vertex.fan_speed);
            add_row(_u8L("Fan speed"), buff);
            sprintf(buff, ("%.0f " + _u8L("\u2103" /* °C */)).c_str(), vertex.temperature);
            add_row(_u8L("Temperature"), buff);
            sprintf(buff, "%.4f", vertex.pressure_advance);
            add_row(_u8L("Pressure Advance"), buff);
            const float estimated_time = viewer->get_estimated_time_at(vertex_id);
            sprintf(buff, "%s (%.3fs)", get_time_dhms(estimated_time).c_str(), vertex.times[static_cast<size_t>(viewer->get_time_mode())]);
            add_row(_u8L("Time"), buff);
 
            table_content_w = 2 * std::max(label_w, value_w) + style.ItemInnerSpacing.x;
        }
 
        // "ToolPosition" layout width calculation
        const float axes_spacing_x = ImGui::CalcTextSize("sp").x;                                  // Spacing between axes labels
        const char* axes_sample    = m_high_precision_gcode ? "X 999.9999" : "X 999.999";          // The longest possible axis label, see the precision of the position below
        const float axes_width     = ImGui::CalcTextSize(axes_sample).x;                           // Width of the longest possible axis label
        const float axes_content_w = 3.0f * axes_width + 2.0f * axes_spacing_x;                    // Three axes
        const float speed_width    = ImGui::CalcTextSize((_u8L("Speed: ") + "9999  ").c_str()).x;  // Width of the longest possible speed label
        const float detail_width   = ImGui::CalcTextSize(detail_buf).x;                            // Width of the detail text
        const float info_content_w = speed_width + detail_width;                                   // Speed + detail
        const float info_group_w   = std::max(axes_content_w, info_content_w);                     // The width of the group containing position and detail info, whichever is wider
        const float fold_button_w  = 24.0f * m_scale;                                              // Width of the fold/unfold button
        const float bottom_row_w   = fold_button_w + style.ItemSpacing.x + info_group_w;           // The width of the bottom row containing the fold button and the info group
        float speed_profile_row_w  = 0.0f;
#if ENABLE_ACTUAL_SPEED_DEBUG
        const float table_btn_width = std::max(ImGui::CalcTextSize(_u8L("Hide").c_str()).x, ImGui::CalcTextSize(_u8L("Show").c_str()).x);
        const float btn_padding_x = 8.0f * m_scale;
 
        if (properties_shown) {
            // The width of the row containing the button to show/hide the actual speed profile table and its label
            speed_profile_row_w = table_btn_width + btn_padding_x * 2.0f + style.ItemSpacing.x + ImGui::CalcTextSize(_u8L("Actual speed profile").c_str()).x;
        }
#endif // ENABLE_ACTUAL_SPEED_DEBUG
        const float properties_w = std::max(table_content_w, speed_profile_row_w);      // The width of the properties section, whichever is wider between the properties table and the speed profile row
        const float content_w    = std::max(bottom_row_w, properties_w);                // The width of the window content, whichever is wider between the bottom row and the properties table
        const float window_w     = std::ceil(content_w + 2.0f * style.WindowPadding.x); // Final window width with padding, rounded up for better look
 
        // "ToolPosition" layout height calculation
        const float text_h         = ImGui::GetTextLineHeight();
        const float item_spacing_y = style.ItemSpacing.y;
        const float cell_pad_y     = style.CellPadding.y;
        const float window_pad_h   = 2.0f * style.WindowPadding.y;
        const float show_button_h  = text_h + 2.0f * 3.0f * m_scale; // ImGuiStyleVar_FramePadding.y is set to 3.f * m_scale
        const float main_row_h     = 2.0f * text_h + item_spacing_y; // Two lines of text (position and detail) + spacing between them
        const float properties_h   = static_cast<float>(properties_rows.size()) * (text_h + 2.0f * cell_pad_y) +  2.0f * cell_pad_y + 1.0f + item_spacing_y // table rows
                                    + item_spacing_y + show_button_h                    // Spacing() + Show/Hide button row
                                    + item_spacing_y + 1.0f + style.WindowPadding.y;    // Spacing() + Separator() + Dummy()
        const float folded_window_h   = std::ceil(window_pad_h + main_row_h);           // Height of the window when properties are hidden, with padding, rounded up for better look
        const float unfolded_window_h = std::ceil(folded_window_h + properties_h);      // Height of the window when properties are shown, with padding, rounded up for better look
        const float window_h = properties_shown ? unfolded_window_h : folded_window_h;  // Final window height depending on whether properties are shown or not
 
        ImGui::SetNextWindowSize(ImVec2(window_w, window_h), ImGuiCond_Always);
 
        imgui.begin(std::string("ToolPosition"), ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoResize);
        ImGui::AlignTextToFramePadding();
 
        if (properties_shown) {
            auto append_table_row = [](const std::string& label, const std::string& value) {
                ImGui::TableNextRow();
                ImGui::TableSetColumnIndex(0);
                ImGuiWrapper::text_colored(ImGuiWrapper::COL_ORCA, label);
                ImGui::TableSetColumnIndex(1);
                ImGuiWrapper::text(value);
            };
 
            if (ImGui::BeginTable("Properties", 2)) {
                for (const auto& row : properties_rows)
                    append_table_row(row.first, row.second);
 
                ImGui::EndTable();
            }
 
#if ENABLE_ACTUAL_SPEED_DEBUG
            bool actual_speed_exist = vertex.is_extrusion() || vertex.is_travel() || vertex.is_wipe();
            static float cached_table_wnd_width = 0.0f;  // ORCA: Cache the calculated window width to avoid recalculation on every frame
            static float cached_table_wnd_scale = 0.0f;  // ORCA: Cache the calculated window scale to avoid recalculation on every frame
            ImGui::Spacing();
 
            static bool table_shown = false;
            imgui.push_confirm_button_style();
            ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding  , 3.f * m_scale);
            ImGui::PushStyleVar(ImGuiStyleVar_FramePadding   , ImVec2(btn_padding_x, 3.f * m_scale));
            ImGui::PushStyleVar(ImGuiStyleVar_ButtonTextAlign, ImVec2(.5f, .5f));
            if (imgui.button((table_shown ? _L("Hide") : _L("Show")).c_str(), ImVec2(table_btn_width + btn_padding_x * 2.f, 0.f), actual_speed_exist))
                table_shown = !table_shown;
            ImGui::PopStyleVar(3);
            imgui.pop_confirm_button_style();
            ImGui::SameLine();
            ImGuiWrapper::text(_u8L("Actual speed profile").c_str()); // ORCA show label and plot on external window to make main window more compact
 
            if (actual_speed_exist && table_shown) {
                const float plot_height = 135.f * m_scale;  // 135 is the height of the plot without labels
 
                if (cached_table_wnd_scale != m_scale) { // ORCA
                    // Catch the window width to avoid recalculation on every frame,
                    // but recalculate it when/if scale changes.
 
                    const float cell_pad_x = 9.f * m_scale; // matches ImGuiStyleVar_CellPadding.x below
                    const float wnd_pad_x = 2.0f * style.WindowPadding.x;
                    const float table_border_x = 6.0f * m_scale;
 
                    // Calculate the width needed to fully show each table column header
                    // but not clamping to a minimum because later the window width is clamped anyway.
                    const float col0_w = ImGui::CalcTextSize((_u8L("Position") + " (" + _u8L("mm") + ")").c_str()).x;
                    const float col1_w = ImGui::CalcTextSize((_u8L("Speed") + " (" + _u8L("mm/s") + ")").c_str()).x;
 
                    const float content_w = std::ceil(col0_w + col1_w + 4.0f * cell_pad_x + table_border_x + wnd_pad_x);
                    const float aspect_w = std::ceil(plot_height * (16.0f / 9.0f)); // 16:9 ratio for better look
                    // Try to obtain 16:9 ratio if possible, but keep enough width for content to make
                    // window looking good on different languages, especially with long words in table header
                    cached_table_wnd_width = std::max(content_w, aspect_w);
                    cached_table_wnd_scale = m_scale;
                }
 
                // ORCA: Pre-calculate the height of the table based on number of rows
                // and clamp the final window height to keep at least the same height as ToolPosition window.
                const float cell_pad_y  = 1.f * m_scale; // ImGuiStyleVar_CellPadding.y below
                const float row_height  = ImGui::GetTextLineHeight() + 2.f * cell_pad_y;
                const float rows        = static_cast<float>(m_actual_speed_imgui_widget.data.size());
                const float table_h     = row_height * (1.0f + rows) + 2.f * m_scale; // border allowance
                const float target_h    = std::ceil(plot_height + table_h + 2.f * style.WindowPadding.y);
                const float min_h       = ImGui::GetWindowHeight(); // keep at least the same height as ToolPosition window
                const float max_h       = static_cast<float>(canvas_height) - 8.f * m_scale; // keep inside canvas with a small margin
                const float final_h     = std::clamp(target_h, min_h, max_h);
                const bool  needs_scroll = target_h > max_h;
                const float table_view_h = std::max(1.0f, final_h - plot_height - 2.f * style.WindowPadding.y);
 
                //const ImVec2 wnd_size = ImGui::GetWindowSize();
                imgui.set_next_window_pos(ImGui::GetWindowPos().x - 5.f * m_scale /*+ wnd_size.x*/, static_cast<float>(canvas_height), ImGuiCond_Always, 1.0f, 1.0f);
                ImGui::SetNextWindowSize(ImVec2(cached_table_wnd_width, final_h), ImGuiCond_Always);
                //ImGui::SetNextWindowSizeConstraints({ 0.0f, 0.0f }, { -1.0f, wnd_size.y });
                imgui.begin(std::string("ToolPositionTableWnd"), ImGuiWindowFlags_NoTitleBar |
                    ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoMove |
                    ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoScrollWithMouse);
                ImGui::PushStyleVar(ImGuiStyleVar_CellPadding, ImVec2(9.f, 1.f) * m_scale);
                ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(0.f, 0.f));
 
                ImVec4 scroll_col    = ImVec4(0.77f, 0.77f, 0.77f, m_is_dark ? .6f : 1.0f); // same color with sliced plates toolbar scrollbar
                ImGui::PushStyleColor(ImGuiCol_ScrollbarBg, ImVec4(0.f, 0.f, 0.f, 0.f)); // ORCA using background color with opacity creates a second color. This prevents secondary color
                ImGui::PushStyleColor(ImGuiCol_ScrollbarGrabActive, scroll_col);
                ImGui::PushStyleColor(ImGuiCol_ScrollbarGrabHovered, scroll_col);
                ImGui::PushStyleColor(ImGuiCol_ScrollbarGrab, scroll_col);
                ImGui::PushStyleColor(ImGuiCol_HeaderHovered , style.Colors[ImGuiCol_TableHeaderBg]);
 
                const int hover_id = m_actual_speed_imgui_widget.plot("##ActualSpeedProfile", { -1.f, plot_height});
                const ImGuiTableFlags table_flags = ImGuiTableFlags_Borders | (needs_scroll ? ImGuiTableFlags_ScrollY : 0);
                if (ImGui::BeginTable("ToolPositionTable", 2, table_flags, ImVec2(0.0f, needs_scroll ? table_view_h : 0.0f))) {
                    char buff[1024];
                    if (needs_scroll)
                        ImGui::TableSetupScrollFreeze(0, 1); // Make top row always visible
                    ImGui::TableSetupColumn((_u8L("Position") + " (" + _u8L("mm")   + ")").c_str());
                    ImGui::TableSetupColumn((_u8L("Speed")    + " (" + _u8L("mm/s") + ")").c_str());
                    ImGui::TableHeadersRow();
                    int counter = 0;
                    for (const ActualSpeedImguiWidget::Item& item : m_actual_speed_imgui_widget.data) {
                        const bool highlight = hover_id >= 0 && (counter == hover_id || counter == hover_id + 1);
                        ImGui::TableNextRow();
                        const ImU32 row_bg_color = ImGui::GetColorU32(item.internal ? ImVec4(0.0f, 150.f / 255.0f, 136.0f / 255.f, 0.15f) : ImVec4(0.2f, 0.2f, 0.2f, 0.25f)); // ORCA
                        ImGui::TableSetBgColor(ImGuiTableBgTarget_RowBg0, row_bg_color);
                        ImGui::TableSetColumnIndex(0);
                        sprintf(buff, "%.3f", item.pos);
                        imgui.text_colored(highlight ? ImGuiWrapper::COL_ORCA : ImGuiWrapper::to_ImVec4(ColorRGBA::WHITE()), buff);
                        ImGui::TableSetColumnIndex(1);
                        sprintf(buff, "%.1f", item.speed);
                        imgui.text_colored(highlight ? ImGuiWrapper::COL_ORCA : ImGuiWrapper::to_ImVec4(ColorRGBA::WHITE()), buff);
                        ++counter;
                    }
 
                    ImGui::EndTable();
                }
                ImGui::PopStyleVar(2);
                ImGui::PopStyleColor(5);
                imgui.end();
            }
 
#endif // ENABLE_ACTUAL_SPEED_DEBUG
 
            ImGui::Spacing();
            ImGui::Separator();
            ImGui::Dummy({0, style.WindowPadding.y});
        }
 
        float draw_area_height = ImGui::GetTextLineHeight() * 2.f + style.ItemSpacing.y;
        ImGui::Dummy({10.f, draw_area_height}); // reserve area
 
        ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding  , 3.f * m_scale);
        ImGui::PushStyleVar(ImGuiStyleVar_FramePadding   , ImVec2(2.f, 2.f) * m_scale);
        ImGui::PushStyleColor(ImGuiCol_Button            , ImVec4(0, 0, 0, 0));
        ImGui::PushStyleColor(ImGuiCol_ButtonHovered     , ImVec4(84 / 255.f, 84 / 255.f, 90 / 255.f, 1.f));
        ImGui::PushStyleColor(ImGuiCol_ButtonActive      , ImVec4(84 / 255.f, 84 / 255.f, 90 / 255.f, 1.f));
         
        const float main_wnd_height = ImGui::GetWindowHeight();
        const float draw_start_y = main_wnd_height - draw_area_height - style.WindowPadding.y;
 
        ImGui::SetCursorPos(ImVec2(style.WindowPadding.x, draw_start_y));
 
        // ORCA use glyph based button for fixing button sizes changing depends on used font size on platform
        const wchar_t foldIcon = properties_shown ? ImGui::UnfoldButtonIcon : ImGui::FoldButtonIcon;
        if (imgui.glyph_button(foldIcon, ImVec2(16.f, 16.f) * m_scale)) {
            properties_shown = !properties_shown;
            static float main_wnd_height_temp = ImGui::GetWindowHeight();
            static float first_click = true;
            if (first_click || main_wnd_height_temp != main_wnd_height) {
                main_wnd_height_temp = main_wnd_height;
                first_click = false;
                imgui.set_requires_extra_frame();
            }
        }
        ImGui::PopStyleColor(3);
        ImGui::PopStyleVar(2);
 
        ImGui::SetCursorPos(ImVec2(style.WindowPadding.x + style.ItemSpacing.x + 24.f * m_scale, draw_start_y - 1.f * m_scale));
 
        ImGui::BeginGroup(); // group contents to make information area more compact
 
        // ORCA Use colorized axis labels & reduce precision on large-scale prints,
        // show one more decimal when the G-code was exported with high precision
        auto pos       = vertex.position;
        int  max_value = std::round(std::max(std::max(pos[0], pos[1]), pos[2]));
        auto precision = m_high_precision_gcode ? (max_value > 9999 ? "%.2f" : max_value > 999 ? "%.3f" : "%.4f")
                                                : (max_value > 9999 ? "%.1f" : max_value > 999 ? "%.2f" : "%.3f");
 
        char xBuf[32];
        ImGui::TextColored(ImGuiWrapper::to_ImVec4(ColorRGBA::X()),"X ");
        ImGui::SameLine(0,0); // ignore item spacing
        sprintf(xBuf, precision, pos[0]);
        ImGui::Text("%s", xBuf);
 
        char yBuf[32];
        ImGui::SameLine(axes_width + axes_spacing_x);
        ImGui::TextColored(ImGuiWrapper::to_ImVec4(ColorRGBA::Y()),"Y ");
        ImGui::SameLine(0,0); // ignore item spacing
        sprintf(yBuf, precision, pos[1]);
        ImGui::Text("%s", yBuf);
 
        char zBuf[32];
        ImGui::SameLine(2.0f * (axes_width + axes_spacing_x));
        ImGui::TextColored(ImGuiWrapper::to_ImVec4(ColorRGBA::Z()),"Z ");
        ImGui::SameLine(0,0); // ignore item spacing
        sprintf(zBuf, precision, pos[2]);
        ImGui::Text("%s", zBuf);
 
        ImGui::SameLine(3.0f * axes_width + 2.0f * axes_spacing_x);
        ImGui::Dummy({0,0});
 
        char spdBuf[128];
        sprintf(spdBuf, "%s%.0f ", _u8L("Speed: ").c_str(), vertex.feedrate);
        ImGuiWrapper::text(spdBuf); // render Speed as different item to keep next item in same place
        
        if (detail_buf[0] != '\0') { // dont render if buffer empty
            ImGui::SameLine(speed_width);
            ImGuiWrapper::text(detail_buf);
        }
        ImGui::EndGroup();
 
        imgui.end();
        ImGui::PopStyleColor(5);
        ImGui::PopStyleVar(2);
    }
    else {
        ImGuiWrapper& imgui = *wxGetApp().imgui();
        //const Size cnv_size = wxGetApp().plater()->get_current_canvas3D()->get_canvas_size();
        //imgui.set_next_window_pos(0.5f * static_cast<float>(cnv_size.get_width()), static_cast<float>(cnv_size.get_height()), ImGuiCond_Always, 0.5f, 1.0f);
        imgui.set_next_window_pos(0.5f * static_cast<float>(canvas_width), static_cast<float>(canvas_height), ImGuiCond_Always, 0.5f, 1.0f);
        ImGui::PushStyleColor(ImGuiCol_Border   , ImVec4(.0f,.0f,.0f,.0f));
        ImGui::PushStyleColor(ImGuiCol_Separator, ImVec4(1.f,1.f,1.f,.6f));
        ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 8.0f * m_scale);
        ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding , ImVec2(10.f, 10.f) * m_scale);
        ImGui::SetNextWindowBgAlpha(0.8f);
        imgui.begin(std::string("ToolPosition"), ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoMove);
 
        const Vec3f pos = m_world_position + m_world_offset + m_z_offset * Vec3f::UnitZ();
 
        int  max_value = std::round(std::max(std::max(pos.x(), pos.y()),pos.z()));
        auto precision = max_value > 9999 ? "%.1f" : max_value > 999 ? "%.2f" : "%.3f";
        const float axes_width = ImGui::CalcTextSize("X 999.999sp").x;
 
        char xBuf[32];
        ImGui::TextColored(ImGuiWrapper::to_ImVec4(ColorRGBA::X()),"X ");
        ImGui::SameLine(0,0); // ignore item spacing
        sprintf(xBuf, precision, pos.x());
        ImGui::Text("%s", xBuf);
 
        char yBuf[32]; 
        ImGui::SameLine(axes_width);
        ImGui::TextColored(ImGuiWrapper::to_ImVec4(ColorRGBA::Y()),"Y ");
        ImGui::SameLine(0,0); // ignore item spacing
        sprintf(yBuf, precision, pos.y());
        ImGui::Text("%s", yBuf);
 
        char zBuf[32];
        ImGui::SameLine(axes_width * 2);
        ImGui::TextColored(ImGuiWrapper::to_ImVec4(ColorRGBA::Z()),"Z ");
        ImGui::SameLine(0,0); // ignore item spacing
        sprintf(zBuf, precision, pos.z());
        ImGui::Text("%s", zBuf);
 
        ImGui::SameLine(axes_width * 3);
        ImGui::Dummy({0,0});
 
        imgui.end();
        ImGui::PopStyleColor(2);
        ImGui::PopStyleVar(2);
    }
}

References _L, _u8L, libvgcode::Acceleration, libvgcode::PathVertex::acceleration, Slic3r::GUI::ImGuiWrapper::begin(), Slic3r::GUI::ImGuiWrapper::button(), Slic3r::GUI::ImGuiWrapper::COL_BUTTON_ACTIVE, Slic3r::GUI::ImGuiWrapper::COL_BUTTON_BACKGROUND, Slic3r::GUI::ImGuiWrapper::COL_BUTTON_HOVERED, Slic3r::GUI::ImGuiWrapper::COL_ORCA, libvgcode::PathVertex::color_id, libvgcode::ColorPrint, libvgcode::convert(), Slic3r::GUI::ImGuiWrapper::end(), libvgcode::PathVertex::extruder_id, libvgcode::PathVertex::fan_speed, libvgcode::FanSpeed, libvgcode::FeatureType, libvgcode::PathVertex::feedrate, libvgcode::PathVertex::gcode_id, libvgcode::Viewer::get_current_vertex(), libvgcode::Viewer::get_current_vertex_id(), libvgcode::Viewer::get_estimated_time_at(), Slic3r::get_time_dhms(), libvgcode::Viewer::get_time_mode(), libvgcode::Viewer::get_vertex_at(), libvgcode::Viewer::get_vertices_count(), libvgcode::Viewer::get_view_visible_range(), Slic3r::GUI::ImGuiWrapper::glyph_button(), libvgcode::Height, libvgcode::PathVertex::height, Slic3r::GUI::highlight(), libvgcode::PathVertex::is_extrusion(), libvgcode::PathVertex::is_travel(), libvgcode::PathVertex::is_wipe(), libvgcode::Jerk, libvgcode::PathVertex::jerk, libvgcode::PathVertex::layer_duration, libvgcode::PathVertex::layer_id, libvgcode::LayerTimeLinear, libvgcode::LayerTimeLogarithmic, Slic3r::length(), m_high_precision_gcode, m_is_dark, m_scale, m_world_offset, m_world_position, m_z_offset, libvgcode::Noop, Slic3r::GUI::ImGuiWrapper::pop_confirm_button_style(), libvgcode::PathVertex::position, libvgcode::PathVertex::pressure_advance, libvgcode::PressureAdvance, Slic3r::GUI::ImGuiWrapper::push_confirm_button_style(), libvgcode::PathVertex::role, libvgcode::Seam, Slic3r::GUI::ImGuiWrapper::set_next_window_pos(), Slic3r::GUI::ImGuiWrapper::set_requires_extra_frame(), style, libvgcode::Temperature, libvgcode::PathVertex::temperature, Slic3r::GUI::ImGuiWrapper::text(), Slic3r::GUI::ImGuiWrapper::text_colored(), libvgcode::PathVertex::times, Slic3r::GUI::ImGuiWrapper::to_ImVec4(), Slic3r::GUI::to_string(), libvgcode::Tool, libvgcode::PathVertex::type, libvgcode::PathVertex::volumetric_rate(), libvgcode::VolumetricFlowRate, Slic3r::ColorRGBA::WHITE(), libvgcode::Width, libvgcode::PathVertex::width, Slic3r::ColorRGBA::X(), Slic3r::ColorRGBA::Y(), and Slic3r::ColorRGBA::Z().

Here is the call graph for this function:

set_color()

void Slic3r::GUI::GCodeViewer::SequentialView::Marker::set_color ( const ColorRGBA & color )

inline

{ m_model.set_color(color); }

References m_model.

set_high_precision_gcode()

void Slic3r::GUI::GCodeViewer::SequentialView::Marker::set_high_precision_gcode ( bool high_precision )

inline

{ m_high_precision_gcode = high_precision; }

References m_high_precision_gcode.

set_visible()

void Slic3r::GUI::GCodeViewer::SequentialView::Marker::set_visible ( bool visible )

inline

{ m_visible = visible; }

References m_visible.

set_world_offset()

void Slic3r::GUI::GCodeViewer::SequentialView::Marker::set_world_offset ( const Vec3f & offset )

inline

{ m_world_offset = offset; }

References m_world_offset, and Slic3r::offset().

Here is the call graph for this function:

set_world_position()

void Slic3r::GUI::GCodeViewer::SequentialView::Marker::set_world_position ( const Vec3f & position )

inline

{ m_world_position = position; }

References m_world_position.

set_z_offset()

void Slic3r::GUI::GCodeViewer::SequentialView::Marker::set_z_offset ( float z_offset )

inline

{ m_z_offset = z_offset; }

References m_z_offset.

Member Data Documentation

m_high_precision_gcode

bool Slic3r::GUI::GCodeViewer::SequentialView::Marker::m_high_precision_gcode { false }

private

{ false };

Referenced by render_position_window(), and set_high_precision_gcode().

m_is_dark

bool Slic3r::GUI::GCodeViewer::SequentialView::Marker::m_is_dark = false

private

Referenced by on_change_color_mode(), and render_position_window().

m_model

GLModel Slic3r::GUI::GCodeViewer::SequentialView::Marker::m_model

private

Referenced by get_bounding_box(), init(), render(), and set_color().

m_model_z_offset

float Slic3r::GUI::GCodeViewer::SequentialView::Marker::m_model_z_offset { 0.5f }

private

{ 0.5f };

Referenced by render().

m_scale

float Slic3r::GUI::GCodeViewer::SequentialView::Marker::m_scale = 1.0f

Referenced by render_position_window().

m_scale_factor

float Slic3r::GUI::GCodeViewer::SequentialView::Marker::m_scale_factor { 1.0f }

private

{ 1.0f };

Referenced by render().

m_visible

bool Slic3r::GUI::GCodeViewer::SequentialView::Marker::m_visible { true }

private

{ true };

Referenced by is_visible(), render(), and set_visible().

m_world_offset

Vec3f Slic3r::GUI::GCodeViewer::SequentialView::Marker::m_world_offset

private

Referenced by render_position_window(), and set_world_offset().

m_world_position

Vec3f Slic3r::GUI::GCodeViewer::SequentialView::Marker::m_world_position

private

Referenced by render(), render_position_window(), and set_world_position().

m_z_offset

float Slic3r::GUI::GCodeViewer::SequentialView::Marker::m_z_offset { 0.0f }

private

{ 0.0f };

Referenced by render_position_window(), and set_z_offset().

---

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

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