Slic3r::GUI::GCodeViewer::SequentialView::GCodeWindow Class Reference

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

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

Classes
struct	Line

Public Member Functions
	GCodeWindow ()=default
	~GCodeWindow ()
void	load_gcode (const std::string &filename, const std::vector< size_t > &lines_ends)
void	reset ()
void	render (float top, float bottom, float right, uint64_t curr_line_id) const
void	on_change_color_mode (bool is_dark)
void	stop_mapping_file ()

Public Attributes
float	m_scale = 1.0f

Private Attributes
bool	m_is_dark = false
uint64_t	m_selected_line_id { 0 }
size_t	m_last_lines_size { 0 }
std::string	m_filename
boost::iostreams::mapped_file_source	m_file
std::vector< size_t >	m_lines_ends
std::vector< Line >	m_lines

Detailed Description

---

Class Documentation

Slic3r::GUI::GCodeViewer::SequentialView::GCodeWindow::Line

struct Slic3r::GUI::GCodeViewer::SequentialView::GCodeWindow::Line

Collaboration diagram for Slic3r::GUI::GCodeViewer::SequentialView::GCodeWindow::Line:

Class Members
string	command
string	comment
string	parameters

Constructor & Destructor Documentation

GCodeWindow()

Slic3r::GUI::GCodeViewer::SequentialView::GCodeWindow::GCodeWindow ( )

default

~GCodeWindow()

Slic3r::GUI::GCodeViewer::SequentialView::GCodeWindow::~GCodeWindow ( )

inline

{ stop_mapping_file(); }

References stop_mapping_file().

Here is the call graph for this function:

Member Function Documentation

load_gcode()

void Slic3r::GUI::GCodeViewer::SequentialView::GCodeWindow::load_gcode	(	const std::string &	filename,
		const std::vector< size_t > &	lines_ends )

{
    assert(! m_file.is_open());
    if (m_file.is_open())
        return;
 
    m_filename   = filename;
    m_lines_ends = lines_ends;
 
    m_selected_line_id = 0;
    m_last_lines_size = 0;
 
    try
    {
        m_file.open(boost::filesystem::path(m_filename));
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": mapping file " << m_filename;
    }
    catch (...)
    {
        BOOST_LOG_TRIVIAL(error) << "Unable to map file " << m_filename << ". Cannot show G-code window.";
        reset();
    }
}

References m_file, m_filename, m_last_lines_size, m_lines_ends, m_selected_line_id, and Slic3r::GUI::GCodeViewer::reset().

Here is the call graph for this function:

on_change_color_mode()

void Slic3r::GUI::GCodeViewer::SequentialView::GCodeWindow::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::GCodeWindow::render	(	float	top,
		float	bottom,
		float	right,
		uint64_t	curr_line_id ) const

{
    // Orca: truncate long lines(>55 characters), add "..." at the end
    auto update_lines = [this](uint64_t start_id, uint64_t end_id) {
        std::vector<Line> ret;
        ret.reserve(end_id - start_id + 1);
        // Orca: m_lines_ends indexes into a memory mapping, so it must be clamped to the mapping. If the
        // file was modified behind our back (an in-place post-processing script that shrank it), an
        // unchecked read is an access violation, which the caller's try/catch cannot catch on Windows.
        const size_t file_size = m_file.size();
        for (uint64_t id = start_id; id <= end_id; ++id) {
            // read line from file
            // Keep one entry per id: render() indexes m_lines by (id - start_id).
            const size_t start = id == 1 ? 0 : std::min(m_lines_ends[id - 2], file_size);
            const size_t end   = std::min(m_lines_ends[id - 1], file_size);
            const size_t original_len = end > start ? end - start : 0;
            // A character is four bytes at most, so 55 of them always fit in 220.
            const size_t len          = std::min(original_len, (size_t) 55 * 4);
            std::string  gline(m_file.data() + start, len);
 
            // If original line is longer than 55 characters, truncate and append "...".
            // The cut must land on a character boundary or it leaves half a character behind.
            if (len < original_len || utf8_offset(gline, 55) < gline.size())
                gline = gline.substr(0, utf8_offset(gline, 52)) + "...";
 
            std::string command, parameters, comment;
            const size_t comment_start = gline.find(';');
            if (comment_start == std::string::npos)
                command = gline;
            else {
                command = gline.substr(0, comment_start);
                comment = gline.substr(comment_start);
            }
 
            // extract gcode command and parameters
            if (!command.empty()) {
                std::vector<std::string> tokens;
                boost::split(tokens, command, boost::is_any_of(" "), boost::token_compress_on);
                command = tokens.front();
                if (tokens.size() > 1) {
                    for (size_t i = 1; i < tokens.size(); ++i) {
                        parameters += " " + tokens[i];
                    }
                }
            }
            ret.push_back({command, parameters, comment});
        }
        return ret;
    };
 
    static const ImVec4 LINE_NUMBER_COLOR    = ImGuiWrapper::COL_ORANGE_LIGHT;
    static const ImVec4 SELECTION_RECT_COLOR = ImGuiWrapper::COL_ORANGE_DARK;
    static const ImVec4 COMMAND_COLOR        = {0.8f, 0.8f, 0.0f, 1.0f};
    static const ImVec4 PARAMETERS_COLOR     = { 1.0f, 1.0f, 1.0f, 1.0f };
    static const ImVec4 COMMENT_COLOR        = { 0.7f, 0.7f, 0.7f, 1.0f };
 
    if (!wxGetApp().show_gcode_window() || m_filename.empty() || m_lines_ends.empty() || curr_line_id == 0)
        return;
 
    // window height
    const float wnd_height = bottom - top;
 
    // number of visible lines
    const float text_height = ImGui::CalcTextSize("0").y;
    const ImGuiStyle& style = ImGui::GetStyle();
    const uint64_t lines_count = static_cast<uint64_t>((wnd_height - 2.0f * style.WindowPadding.y + style.ItemSpacing.y) / (text_height + style.ItemSpacing.y));
 
    if (lines_count == 0)
        return;
 
    // visible range
    const uint64_t half_lines_count = lines_count / 2;
    uint64_t start_id = (curr_line_id >= half_lines_count) ? curr_line_id - half_lines_count : 0;
    uint64_t end_id = start_id + lines_count - 1;
    if (end_id >= static_cast<uint64_t>(m_lines_ends.size())) {
        end_id = static_cast<uint64_t>(m_lines_ends.size()) - 1;
        start_id = end_id - lines_count + 1;
    }
 
    // updates list of lines to show, if needed
    if (m_selected_line_id != curr_line_id || m_last_lines_size != end_id - start_id + 1) {
        try
        {
            *const_cast<std::vector<Line>*>(&m_lines) = update_lines(start_id, end_id);
        }
        catch (...)
        {
            BOOST_LOG_TRIVIAL(error) << "Error while loading from file " << m_filename << ". Cannot show G-code window.";
            return;
        }
        *const_cast<uint64_t*>(&m_selected_line_id) = curr_line_id;
        *const_cast<size_t*>(&m_last_lines_size) = m_lines.size();
    }
 
    // line number's column width
    const float id_width = ImGui::CalcTextSize(std::to_string(end_id).c_str()).x;
 
    float required_width = 0.0f;
    { // --- Compute required G-code window width ---
        float max_text_width = id_width;
        for (const Line& line : m_lines) {
            float w = 0.0f;
 
            if (!line.command.empty())
                w += ImGui::CalcTextSize(line.command.c_str()).x;
 
            if (!line.parameters.empty())
                w += ImGui::CalcTextSize(line.parameters.c_str()).x;
 
            if (!line.comment.empty())
                w += ImGui::CalcTextSize(line.comment.c_str()).x;
 
            // spacing between segments
            w += 3 * ImGui::GetStyle().ItemSpacing.x;
 
            if (w > max_text_width)
                max_text_width = w;
        }
 
        required_width = id_width + max_text_width;
    }
 
    ImGuiWrapper& imgui = *wxGetApp().imgui();
 
    //BBS: GUI refactor: move to right
    imgui.set_next_window_pos(right, top + 6 * m_scale, ImGuiCond_Always, 1.0f, 0.0f); // ORCA add a small gap between legend and code viewer
    ImGui::SetNextWindowSize(ImVec2(required_width, wnd_height), ImGuiCond_Always);
    ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 8.0f * m_scale); // ORCA add window rounding to modernize / match style
    ImGui::SetNextWindowBgAlpha(0.8f);
    imgui.begin(std::string("G-code"), ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoMove);
 
    // center the text in the window by pushing down the first line
    const float f_lines_count = static_cast<float>(lines_count);
    ImGui::SetCursorPosY(0.5f * (wnd_height - f_lines_count * text_height - (f_lines_count - 1.0f) * style.ItemSpacing.y));
 
    // render text lines
    for (uint64_t id = start_id; id <= end_id; ++id) {
        const Line& line = m_lines[id - start_id];
 
        // rect around the current selected line
        if (id == curr_line_id) {
            //BBS: GUI refactor: move to right
            const float pos_y = ImGui::GetCursorScreenPos().y;
            const float pos_x = ImGui::GetCursorScreenPos().x;
            const float half_ItemSpacing_y = 0.5f * style.ItemSpacing.y;
            const float half_ItemSpacing_x = 0.5f * style.ItemSpacing.x;
            //ImGui::GetWindowDrawList()->AddRect({ half_padding_x, pos_y - half_ItemSpacing_y },
            //    { ImGui::GetCurrentWindow()->Size.x - half_padding_x, pos_y + text_height + half_ItemSpacing_y },
            //    ImGui::GetColorU32(SELECTION_RECT_COLOR));
            ImGui::GetWindowDrawList()->AddRect({ pos_x - half_ItemSpacing_x, pos_y - half_ItemSpacing_y },
                { right - half_ItemSpacing_x, pos_y + text_height + half_ItemSpacing_y },
                ImGui::GetColorU32(SELECTION_RECT_COLOR));
        }
 
        // render line number
        const std::string id_str = std::to_string(id);
        // spacer to right align text
        ImGui::Dummy({ id_width - ImGui::CalcTextSize(id_str.c_str()).x, text_height });
        ImGui::SameLine(0.0f, 0.0f);
        ImGui::PushStyleColor(ImGuiCol_Text, LINE_NUMBER_COLOR);
        imgui.text(id_str);
        ImGui::PopStyleColor();
 
        if (!line.command.empty() || !line.comment.empty())
            ImGui::SameLine();
 
        // render command
        if (!line.command.empty()) {
            ImGui::PushStyleColor(ImGuiCol_Text, COMMAND_COLOR);
            imgui.text(line.command);
            ImGui::PopStyleColor();
        }
 
        // render parameters
        if (!line.parameters.empty()) {
            ImGui::SameLine(0.0f, 0.0f);
            ImGui::PushStyleColor(ImGuiCol_Text, PARAMETERS_COLOR);
            imgui.text(line.parameters);
            ImGui::PopStyleColor();
        }
 
        // render comment
        if (!line.comment.empty()) {
            if (!line.command.empty())
                ImGui::SameLine(0.0f, 0.0f);
            ImGui::PushStyleColor(ImGuiCol_Text, COMMENT_COLOR);
            imgui.text(line.comment);
            ImGui::PopStyleColor();
        }
    }
 
    imgui.end();
    ImGui::PopStyleVar();
}

References Slic3r::GUI::ImGuiWrapper::begin(), Slic3r::GUI::ImGuiWrapper::COL_ORANGE_DARK, Slic3r::GUI::ImGuiWrapper::COL_ORANGE_LIGHT, Slic3r::GUI::GCodeViewer::SequentialView::GCodeWindow::Line::command, Slic3r::GUI::GCodeViewer::SequentialView::GCodeWindow::Line::comment, Slic3r::GUI::ImGuiWrapper::end(), m_file, m_filename, m_last_lines_size, m_lines, m_lines_ends, m_scale, m_selected_line_id, Slic3r::GUI::GCodeViewer::SequentialView::GCodeWindow::Line::parameters, Slic3r::GUI::ImGuiWrapper::set_next_window_pos(), style, Slic3r::GUI::ImGuiWrapper::text(), and Slic3r::GUI::utf8_offset().

Here is the call graph for this function:

reset()

void Slic3r::GUI::GCodeViewer::SequentialView::GCodeWindow::reset ( )

inline

                         {
                stop_mapping_file();
                m_lines_ends.clear();
                m_lines_ends.shrink_to_fit();
                m_lines.clear();
                m_lines.shrink_to_fit();
                m_filename.clear();
                m_filename.shrink_to_fit();
            }

References m_filename, m_lines, m_lines_ends, and stop_mapping_file().

Here is the call graph for this function:

stop_mapping_file()

void Slic3r::GUI::GCodeViewer::SequentialView::GCodeWindow::stop_mapping_file

(

)

{
    //BBS: add log to trace the gcode file issue
    if (m_file.is_open()) {
        m_file.close();
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": finished mapping file " << m_filename;
    }
}

References m_file, and m_filename.

Referenced by ~GCodeWindow(), and reset().

Here is the caller graph for this function:

Member Data Documentation

m_file

boost::iostreams::mapped_file_source Slic3r::GUI::GCodeViewer::SequentialView::GCodeWindow::m_file

private

Referenced by load_gcode(), render(), and stop_mapping_file().

m_filename

std::string Slic3r::GUI::GCodeViewer::SequentialView::GCodeWindow::m_filename

private

Referenced by load_gcode(), render(), reset(), and stop_mapping_file().

m_is_dark

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

private

Referenced by on_change_color_mode().

m_last_lines_size

size_t Slic3r::GUI::GCodeViewer::SequentialView::GCodeWindow::m_last_lines_size { 0 }

private

{ 0 };

Referenced by load_gcode(), and render().

m_lines

std::vector<Line> Slic3r::GUI::GCodeViewer::SequentialView::GCodeWindow::m_lines

private

Referenced by render(), and reset().

m_lines_ends

std::vector<size_t> Slic3r::GUI::GCodeViewer::SequentialView::GCodeWindow::m_lines_ends

private

Referenced by load_gcode(), render(), and reset().

m_scale

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

Referenced by render().

m_selected_line_id

uint64_t Slic3r::GUI::GCodeViewer::SequentialView::GCodeWindow::m_selected_line_id { 0 }

private

{ 0 };

Referenced by load_gcode(), and render().

---

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