Slic3r::GUI::TickCodeInfo Class Reference

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

Collaboration diagram for Slic3r::GUI::TickCodeInfo:

Public Member Functions
bool	empty () const
void	set_pause_print_msg (const std::string &message)
bool	add_tick (const int tick, CustomGCode::Type type, int extruder, double print_z)
bool	edit_tick (std::set< TickCode >::iterator it, double print_z)
void	switch_code (CustomGCode::Type type_from, CustomGCode::Type type_to)
bool	switch_code_for_tick (std::set< TickCode >::iterator it, CustomGCode::Type type_to, const int extruder)
void	erase_all_ticks_with_code (CustomGCode::Type type)
bool	has_tick_with_code (CustomGCode::Type type)
bool	has_tick (int tick)
void	suppress_plus (bool suppress)
void	suppress_minus (bool suppress)
bool	suppressed_plus ()
bool	suppressed_minus ()
void	set_default_colors (bool default_colors_on)
void	set_extruder_colors (std::vector< std::string > *extruder_colors)

Public Attributes
std::set< TickCode >	ticks {}
CustomGCode::Mode	mode = CustomGCode::Undef

Private Member Functions
std::string	get_color_for_tick (TickCode tick, CustomGCode::Type type, const int extruder)

Private Attributes
std::string	pause_print_msg
bool	m_suppress_plus = false
bool	m_suppress_minus = false
bool	m_use_default_colors = false
std::vector< std::string > *	m_colors { nullptr }

Detailed Description

Member Function Documentation

add_tick()

bool Slic3r::GUI::TickCodeInfo::add_tick	(	const int	tick,
		CustomGCode::Type	type,
		int	extruder,
		double	print_z )

{
    std::string color;
    std::string extra;
    if (type == Custom) // custom Gcode
    {
        //extra = get_custom_code(custom_gcode, print_z);
        //if (extra.empty()) return false;
        //custom_gcode = extra;
    } else if (type == PausePrint) {
        //BBS do not set pause extra message
        //extra = get_pause_print_msg(pause_print_msg, print_z);
        //if (extra.empty()) return false;
        pause_print_msg = extra;
    }
    else {
        color = get_color_for_tick(TickCode{ tick }, type, extruder);
        if (color.empty()) return false;
    }
 
    if (mode == SingleExtruder) m_use_default_colors = true;
 
    ticks.emplace(TickCode{tick, type, extruder, color, extra});
 
    return true;
}

References Slic3r::CustomGCode::Custom, get_color_for_tick(), m_use_default_colors, mode, pause_print_msg, Slic3r::CustomGCode::PausePrint, Slic3r::CustomGCode::SingleExtruder, and ticks.

Here is the call graph for this function:

edit_tick()

bool Slic3r::GUI::TickCodeInfo::edit_tick	(	std::set< TickCode >::iterator	it,
		double	print_z )

{
    std::string edited_value;
    //TODO
    /* BBS
    if (it->type == ColorChange)
        edited_value = get_new_color(it->color);
    else if (it->type == PausePrint)
        edited_value = get_pause_print_msg(it->extra, print_z);
    else
        edited_value = get_custom_code(it->type == Template ? gcode(Template) : it->extra, print_z);
    */
    if (edited_value.empty()) return false;
 
    TickCode changed_tick = *it;
    if (it->type == ColorChange) {
        if (it->color == edited_value) return false;
        changed_tick.color = edited_value;
    } else if (it->type == Template) {
        //if (gcode(Template) == edited_value) return false;
        //changed_tick.extra = edited_value;
        //changed_tick.type  = Custom;
        ;
    } else if (it->type == Custom || it->type == PausePrint) {
        if (it->extra == edited_value) return false;
        changed_tick.extra = edited_value;
    }
 
    ticks.erase(it);
    ticks.emplace(changed_tick);
 
    return true;
}

References Slic3r::GUI::TickCode::color, Slic3r::CustomGCode::ColorChange, Slic3r::CustomGCode::Custom, Slic3r::GUI::TickCode::extra, Slic3r::CustomGCode::PausePrint, Slic3r::CustomGCode::Template, and ticks.

empty()

bool Slic3r::GUI::TickCodeInfo::empty ( ) const

inline

{ return ticks.empty(); }

References ticks.

erase_all_ticks_with_code()

void Slic3r::GUI::TickCodeInfo::erase_all_ticks_with_code

(

CustomGCode::Type

type

)

{
    for (auto it{ticks.begin()}, end{ticks.end()}; it != end;) {
        if (it->type == type)
            it = ticks.erase(it);
        else
            ++it;
    }
}

References ticks.

get_color_for_tick()

std::string Slic3r::GUI::TickCodeInfo::get_color_for_tick ( TickCode tick, CustomGCode::Type type, const int extruder )

private

{
    auto opposite_one_color = [](const std::string& color) {
        ColorRGB rgb;
        decode_color(color, rgb);
        return encode_color(opposite(rgb));
    };
    auto opposite_two_colors = [](const std::string& a, const std::string& b) {
        ColorRGB rgb1; decode_color(a, rgb1);
        ColorRGB rgb2; decode_color(b, rgb2);
        return encode_color(opposite(rgb1, rgb2));
    };
 
    if (mode == SingleExtruder && type == ColorChange && m_use_default_colors) {
#if 1
        if (ticks.empty()) return opposite_one_color((*m_colors)[0]);
 
        auto before_tick_it = std::lower_bound(ticks.begin(), ticks.end(), tick);
        if (before_tick_it == ticks.end()) {
            while (before_tick_it != ticks.begin())
                if (--before_tick_it; before_tick_it->type == ColorChange) break;
            if (before_tick_it->type == ColorChange) return opposite_one_color(before_tick_it->color);
            return opposite_one_color((*m_colors)[0]);
        }
 
        if (before_tick_it == ticks.begin()) {
            const std::string &frst_color = (*m_colors)[0];
            if (before_tick_it->type == ColorChange) return opposite_two_colors(frst_color, before_tick_it->color);
 
            auto next_tick_it = before_tick_it;
            while (next_tick_it != ticks.end())
                if (++next_tick_it; next_tick_it->type == ColorChange) break;
            if (next_tick_it->type == ColorChange) return opposite_two_colors(frst_color, next_tick_it->color);
 
            return opposite_one_color(frst_color);
        }
 
        std::string frst_color = "";
        if (before_tick_it->type == ColorChange)
            frst_color = before_tick_it->color;
        else {
            auto next_tick_it = before_tick_it;
            while (next_tick_it != ticks.end())
                if (++next_tick_it; next_tick_it->type == ColorChange) {
                    frst_color = next_tick_it->color;
                    break;
                }
        }
 
        while (before_tick_it != ticks.begin())
            if (--before_tick_it; before_tick_it->type == ColorChange) break;
 
        if (before_tick_it->type == ColorChange) {
            if (frst_color.empty()) return opposite_one_color(before_tick_it->color);
            return opposite_two_colors(before_tick_it->color, frst_color);
        }
 
        if (frst_color.empty()) return opposite_one_color((*m_colors)[0]);
        return opposite_two_colors((*m_colors)[0], frst_color);
#else
        const std::vector<std::string> &colors = ColorPrintColors::get();
        if (ticks.empty()) return colors[0];
        m_default_color_idx++;
 
        return colors[m_default_color_idx % colors.size()];
#endif
    }
 
    std::string color = (*m_colors)[extruder - 1];
 
    if (type == ColorChange) {
        if (!ticks.empty()) {
            auto before_tick_it = std::lower_bound(ticks.begin(), ticks.end(), tick);
            while (before_tick_it != ticks.begin()) {
                --before_tick_it;
                if (before_tick_it->type == ColorChange && before_tick_it->extruder == extruder) {
                    color = before_tick_it->color;
                    break;
                }
            }
        }
 
        //TODO
        //color = get_new_color(color);
    }
    return color;
}

References Slic3r::CustomGCode::ColorChange, Slic3r::GUI::decode_color(), Slic3r::encode_color(), Slic3r::ColorPrintColors::get(), m_colors, m_use_default_colors, mode, Slic3r::opposite(), Slic3r::CustomGCode::SingleExtruder, and ticks.

Referenced by add_tick(), and switch_code_for_tick().

Here is the call graph for this function:

Here is the caller graph for this function:

has_tick()

bool Slic3r::GUI::TickCodeInfo::has_tick

(

int

tick

)

{ return ticks.find(TickCode{tick}) != ticks.end(); }

References ticks.

has_tick_with_code()

bool Slic3r::GUI::TickCodeInfo::has_tick_with_code

(

CustomGCode::Type

type

)

{
    for (const TickCode &tick : ticks)
        if (tick.type == type) return true;
 
    return false;
}

References ticks.

set_default_colors()

void Slic3r::GUI::TickCodeInfo::set_default_colors ( bool default_colors_on )

inline

{ m_use_default_colors = default_colors_on; }

References m_use_default_colors.

set_extruder_colors()

void Slic3r::GUI::TickCodeInfo::set_extruder_colors ( std::vector< std::string > * extruder_colors )

inline

{ m_colors = extruder_colors; }

References m_colors.

set_pause_print_msg()

void Slic3r::GUI::TickCodeInfo::set_pause_print_msg ( const std::string & message )

inline

{ pause_print_msg = message; }

References pause_print_msg.

suppress_minus()

void Slic3r::GUI::TickCodeInfo::suppress_minus ( bool suppress )

inline

{ m_suppress_minus = suppress; }

References m_suppress_minus.

suppress_plus()

void Slic3r::GUI::TickCodeInfo::suppress_plus ( bool suppress )

inline

{ m_suppress_plus = suppress; }

References m_suppress_plus.

suppressed_minus()

bool Slic3r::GUI::TickCodeInfo::suppressed_minus ( )

inline

{ return m_suppress_minus; }

References m_suppress_minus.

suppressed_plus()

bool Slic3r::GUI::TickCodeInfo::suppressed_plus ( )

inline

{ return m_suppress_plus; }

References m_suppress_plus.

switch_code()

void Slic3r::GUI::TickCodeInfo::switch_code	(	CustomGCode::Type	type_from,
		CustomGCode::Type	type_to )

{
    for (auto it{ticks.begin()}, end{ticks.end()}; it != end;)
        if (it->type == type_from) {
            TickCode tick = *it;
            tick.type     = type_to;
            tick.extruder = 1;
            ticks.erase(it);
            it = ticks.emplace(tick).first;
        } else
            ++it;
}

References Slic3r::GUI::TickCode::extruder, ticks, and Slic3r::GUI::TickCode::type.

switch_code_for_tick()

bool Slic3r::GUI::TickCodeInfo::switch_code_for_tick	(	std::set< TickCode >::iterator	it,
		CustomGCode::Type	type_to,
		const int	extruder )

{
    const std::string color = get_color_for_tick(*it, type_to, extruder);
    if (color.empty()) return false;
 
    TickCode changed_tick = *it;
    changed_tick.type     = type_to;
    changed_tick.extruder = extruder;
    changed_tick.color    = color;
 
    ticks.erase(it);
    ticks.emplace(changed_tick);
 
    return true;
}

References Slic3r::GUI::TickCode::color, Slic3r::GUI::TickCode::extruder, get_color_for_tick(), ticks, and Slic3r::GUI::TickCode::type.

Here is the call graph for this function:

Member Data Documentation

m_colors

std::vector<std::string>* Slic3r::GUI::TickCodeInfo::m_colors { nullptr }

private

{ nullptr };// reference to IMSlider::m_extruder_colors

Referenced by get_color_for_tick(), and set_extruder_colors().

m_suppress_minus

bool Slic3r::GUI::TickCodeInfo::m_suppress_minus = false

private

Referenced by suppress_minus(), and suppressed_minus().

m_suppress_plus

bool Slic3r::GUI::TickCodeInfo::m_suppress_plus = false

private

Referenced by suppress_plus(), and suppressed_plus().

m_use_default_colors

bool Slic3r::GUI::TickCodeInfo::m_use_default_colors = false

private

Referenced by add_tick(), get_color_for_tick(), and set_default_colors().

mode

CustomGCode::Mode Slic3r::GUI::TickCodeInfo::mode = CustomGCode::Undef

Referenced by add_tick(), and get_color_for_tick().

pause_print_msg

std::string Slic3r::GUI::TickCodeInfo::pause_print_msg

private

Referenced by add_tick(), and set_pause_print_msg().

ticks

std::set<TickCode> Slic3r::GUI::TickCodeInfo::ticks {}

{};

Referenced by add_tick(), edit_tick(), empty(), erase_all_ticks_with_code(), get_color_for_tick(), has_tick(), has_tick_with_code(), switch_code(), and switch_code_for_tick().

---

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

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