path: root/src/slic3r/GUI/DoubleSlider.cpp

#include "wxExtensions.hpp"
#include "libslic3r/GCode/PreviewData.hpp"
#include "GUI.hpp"
#include "GUI_App.hpp"
#include "I18N.hpp"
#include "ExtruderSequenceDialog.hpp"
#include "libslic3r/Print.hpp"

#include <wx/button.h>
#include <wx/dialog.h>
#include <wx/sizer.h>
#include <wx/slider.h>
#include <wx/menu.h>
#include <wx/bmpcbox.h>
#include <wx/statline.h>
#include <wx/dcclient.h>
#include <wx/numformatter.h>
#include <wx/colordlg.h>

#include <cmath>
#include <boost/algorithm/string/replace.hpp>
#include "Field.hpp"

namespace Slic3r {

using GUI::from_u8;
using GUI::into_u8;

namespace DoubleSlider {

wxDEFINE_EVENT(wxCUSTOMEVT_TICKSCHANGED, wxEvent);

Control::Control( wxWindow *parent,
                  wxWindowID id,
                  int lowerValue, 
                  int higherValue, 
                  int minValue, 
                  int maxValue,
                  const wxPoint& pos,
                  const wxSize& size,
                  long style,
                  const wxValidator& val,
                  const wxString& name) : 
    wxControl(parent, id, pos, size, wxWANTS_CHARS | wxBORDER_NONE),
    m_lower_value(lowerValue), 
    m_higher_value (higherValue), 
    m_min_value(minValue), 
    m_max_value(maxValue),
    m_style(style == wxSL_HORIZONTAL || style == wxSL_VERTICAL ? style: wxSL_HORIZONTAL)
{
#ifdef __WXOSX__ 
    is_osx = true;
#endif //__WXOSX__
    if (!is_osx)
        SetDoubleBuffered(true);// SetDoubleBuffered exists on Win and Linux/GTK, but is missing on OSX

    m_bmp_thumb_higher = (style == wxSL_HORIZONTAL ? ScalableBitmap(this, "right_half_circle.png") : ScalableBitmap(this, "thumb_up"));
    m_bmp_thumb_lower  = (style == wxSL_HORIZONTAL ? ScalableBitmap(this, "left_half_circle.png" ) : ScalableBitmap(this, "thumb_down"));
    m_thumb_size = m_bmp_thumb_lower.GetBmpSize();

    m_bmp_add_tick_on  = ScalableBitmap(this, "colorchange_add");
    m_bmp_add_tick_off = ScalableBitmap(this, "colorchange_add_f");
    m_bmp_del_tick_on  = ScalableBitmap(this, "colorchange_del");
    m_bmp_del_tick_off = ScalableBitmap(this, "colorchange_del_f");
    m_tick_icon_dim = m_bmp_add_tick_on.GetBmpWidth();

    m_bmp_one_layer_lock_on    = ScalableBitmap(this, "lock_closed");
    m_bmp_one_layer_lock_off   = ScalableBitmap(this, "lock_closed_f");
    m_bmp_one_layer_unlock_on  = ScalableBitmap(this, "lock_open");
    m_bmp_one_layer_unlock_off = ScalableBitmap(this, "lock_open_f");
    m_lock_icon_dim   = m_bmp_one_layer_lock_on.GetBmpWidth();

    m_bmp_revert               = ScalableBitmap(this, "undo");
    m_revert_icon_dim = m_bmp_revert.GetBmpWidth();
    m_bmp_cog                  = ScalableBitmap(this, "cog");
    m_cog_icon_dim    = m_bmp_cog.GetBmpWidth();

    m_selection = ssUndef;
    m_ticks.set_pause_print_msg(_utf8(L("Place bearings in slots and resume printing")));
    m_ticks.set_extruder_colors(&m_extruder_colors);

    // slider events
    this->Bind(wxEVT_PAINT,       &Control::OnPaint,    this);
    this->Bind(wxEVT_CHAR,        &Control::OnChar,     this);
    this->Bind(wxEVT_LEFT_DOWN,   &Control::OnLeftDown, this);
    this->Bind(wxEVT_MOTION,      &Control::OnMotion,   this);
    this->Bind(wxEVT_LEFT_UP,     &Control::OnLeftUp,   this);
    this->Bind(wxEVT_MOUSEWHEEL,  &Control::OnWheel,    this);
    this->Bind(wxEVT_ENTER_WINDOW,&Control::OnEnterWin, this);
    this->Bind(wxEVT_LEAVE_WINDOW,&Control::OnLeaveWin, this);
    this->Bind(wxEVT_KEY_DOWN,    &Control::OnKeyDown,  this);
    this->Bind(wxEVT_KEY_UP,      &Control::OnKeyUp,    this);
    this->Bind(wxEVT_RIGHT_DOWN,  &Control::OnRightDown,this);
    this->Bind(wxEVT_RIGHT_UP,    &Control::OnRightUp,  this);

    // control's view variables
    SLIDER_MARGIN     = 4 + GUI::wxGetApp().em_unit();

    DARK_ORANGE_PEN   = wxPen(wxColour(237, 107, 33));
    ORANGE_PEN        = wxPen(wxColour(253, 126, 66));
    LIGHT_ORANGE_PEN  = wxPen(wxColour(254, 177, 139));

    DARK_GREY_PEN     = wxPen(wxColour(128, 128, 128));
    GREY_PEN          = wxPen(wxColour(164, 164, 164));
    LIGHT_GREY_PEN    = wxPen(wxColour(204, 204, 204));

    m_line_pens = { &DARK_GREY_PEN, &GREY_PEN, &LIGHT_GREY_PEN };
    m_segm_pens = { &DARK_ORANGE_PEN, &ORANGE_PEN, &LIGHT_ORANGE_PEN };

    const wxFont& font = GetFont();
    m_font = is_osx ? font.Smaller().Smaller() : font.Smaller();
}

void Control::msw_rescale()
{
    const wxFont& font = GUI::wxGetApp().normal_font();
    m_font = is_osx ? font.Smaller().Smaller() : font.Smaller();

    m_bmp_thumb_higher.msw_rescale();
    m_bmp_thumb_lower .msw_rescale();
    m_thumb_size = m_bmp_thumb_lower.bmp().GetSize();

    m_bmp_add_tick_on .msw_rescale();
    m_bmp_add_tick_off.msw_rescale();
    m_bmp_del_tick_on .msw_rescale();
    m_bmp_del_tick_off.msw_rescale();
    m_tick_icon_dim = m_bmp_add_tick_on.bmp().GetSize().x;

    m_bmp_one_layer_lock_on   .msw_rescale();
    m_bmp_one_layer_lock_off  .msw_rescale();
    m_bmp_one_layer_unlock_on .msw_rescale();
    m_bmp_one_layer_unlock_off.msw_rescale();
    m_lock_icon_dim = m_bmp_one_layer_lock_on.bmp().GetSize().x;

    m_bmp_revert.msw_rescale();
    m_revert_icon_dim = m_bmp_revert.bmp().GetSize().x;
    m_bmp_cog.msw_rescale();
    m_cog_icon_dim = m_bmp_cog.bmp().GetSize().x;

    SLIDER_MARGIN = 4 + GUI::wxGetApp().em_unit();

    SetMinSize(get_min_size());
    GetParent()->Layout();
}

int Control::GetActiveValue() const
{
    return m_selection == ssLower ?
    m_lower_value : m_selection == ssHigher ?
                m_higher_value : -1;
}

wxSize Control::get_min_size() const
{
    const int min_side = GUI::wxGetApp().em_unit() * ( is_horizontal() ? (is_osx ? 8 : 6) : 10 );

    return wxSize(min_side, min_side);
}

wxSize Control::DoGetBestSize() const
{
    const wxSize size = wxControl::DoGetBestSize();
    if (size.x > 1 && size.y > 1)
        return size;
    return get_min_size();
}

void Control::SetLowerValue(const int lower_val)
{
    m_selection = ssLower;
    m_lower_value = lower_val;
    correct_lower_value();
    Refresh();
    Update();

    wxCommandEvent e(wxEVT_SCROLL_CHANGED);
    e.SetEventObject(this);
    ProcessWindowEvent(e);
}

void Control::SetHigherValue(const int higher_val)
{
    m_selection = ssHigher;
    m_higher_value = higher_val;
    correct_higher_value();
    Refresh();
    Update();

    wxCommandEvent e(wxEVT_SCROLL_CHANGED);
    e.SetEventObject(this);
    ProcessWindowEvent(e);
}

void Control::SetSelectionSpan(const int lower_val, const int higher_val)
{
    m_lower_value  = std::max(lower_val, m_min_value);
    m_higher_value = std::max(std::min(higher_val, m_max_value), m_lower_value);
    if (m_lower_value < m_higher_value)
        m_is_one_layer = false;

    Refresh();
    Update();

    wxCommandEvent e(wxEVT_SCROLL_CHANGED);
    e.SetEventObject(this);
    ProcessWindowEvent(e);
}

void Control::SetMaxValue(const int max_value)
{
    m_max_value = max_value;
    Refresh();
    Update();
}

void Control::draw_scroll_line(wxDC& dc, const int lower_pos, const int higher_pos)
{
    int width;
    int height;
    get_size(&width, &height);

    wxCoord line_beg_x = is_horizontal() ? SLIDER_MARGIN : width*0.5 - 1;
    wxCoord line_beg_y = is_horizontal() ? height*0.5 - 1 : SLIDER_MARGIN;
    wxCoord line_end_x = is_horizontal() ? width - SLIDER_MARGIN + 1 : width*0.5 - 1;
    wxCoord line_end_y = is_horizontal() ? height*0.5 - 1 : height - SLIDER_MARGIN + 1;

    wxCoord segm_beg_x = is_horizontal() ? lower_pos : width*0.5 - 1;
    wxCoord segm_beg_y = is_horizontal() ? height*0.5 - 1 : lower_pos/*-1*/;
    wxCoord segm_end_x = is_horizontal() ? higher_pos : width*0.5 - 1;
    wxCoord segm_end_y = is_horizontal() ? height*0.5 - 1 : higher_pos-1;

    for (size_t id = 0; id < m_line_pens.size(); id++)
    {
        dc.SetPen(*m_line_pens[id]);
        dc.DrawLine(line_beg_x, line_beg_y, line_end_x, line_end_y);
        dc.SetPen(*m_segm_pens[id]);
        dc.DrawLine(segm_beg_x, segm_beg_y, segm_end_x, segm_end_y);
        if (is_horizontal())
            line_beg_y = line_end_y = segm_beg_y = segm_end_y += 1;
        else
            line_beg_x = line_end_x = segm_beg_x = segm_end_x += 1;
    }
}

double Control::get_scroll_step()
{
    const wxSize sz = get_size();
    const int& slider_len = m_style == wxSL_HORIZONTAL ? sz.x : sz.y;
    return double(slider_len - SLIDER_MARGIN * 2) / (m_max_value - m_min_value);
}

// get position on the slider line from entered value
wxCoord Control::get_position_from_value(const int value)
{
    const double step = get_scroll_step();
    const int val = is_horizontal() ? value : m_max_value - value;
    return wxCoord(SLIDER_MARGIN + int(val*step + 0.5));
}

wxSize Control::get_size()
{
    int w, h;
    get_size(&w, &h);
    return wxSize(w, h);
}

void Control::get_size(int *w, int *h)
{
    GetSize(w, h);
    is_horizontal() ? *w -= m_lock_icon_dim : *h -= m_lock_icon_dim;
}

double Control::get_double_value(const SelectedSlider& selection)
{
    if (m_values.empty() || m_lower_value<0)
        return 0.0;
    if (m_values.size() <= m_higher_value) {
        correct_higher_value();
        return m_values.back();
    }
    return m_values[selection == ssLower ? m_lower_value : m_higher_value];
}

using t_custom_code = CustomGCode::Item;
CustomGCode::Info Control::GetTicksValues() const
{
    CustomGCode::Info custom_gcode_per_print_z;
    std::vector<t_custom_code>& values = custom_gcode_per_print_z.gcodes;

    const int val_size = m_values.size();
    if (!m_values.empty())
        for (const TickCode& tick : m_ticks.ticks) {
            if (tick.tick > val_size)
                break;
            values.emplace_back(t_custom_code{m_values[tick.tick], tick.gcode, tick.extruder, tick.color});
        }

    if (m_force_mode_apply)
        custom_gcode_per_print_z.mode = m_mode;

    return custom_gcode_per_print_z;
}

void Control::SetTicksValues(const CustomGCode::Info& custom_gcode_per_print_z)
{
    if (m_values.empty())
    {
        m_ticks.mode = m_mode;
        return;
    }

    const bool was_empty = m_ticks.empty();

    m_ticks.ticks.clear();
    const std::vector<t_custom_code>& heights = custom_gcode_per_print_z.gcodes;
    for (auto h : heights) {
        auto it = std::lower_bound(m_values.begin(), m_values.end(), h.print_z - epsilon());

        if (it == m_values.end())
            continue;

        m_ticks.ticks.emplace(TickCode{int(it-m_values.begin()), h.gcode, h.extruder, h.color});
    }
    
    if (!was_empty && m_ticks.empty())
        // Switch to the "Feature type"/"Tool" from the very beginning of a new object slicing after deleting of the old one
        post_ticks_changed_event();

    if (custom_gcode_per_print_z.mode)
        m_ticks.mode = custom_gcode_per_print_z.mode;

    Refresh();
    Update();
}

void Control::SetDrawMode(bool is_sla_print, bool is_sequential_print)
{ 
    m_draw_mode = is_sla_print          ? dmSlaPrint            : 
                  is_sequential_print   ? dmSequentialFffPrint  : 
                                          dmRegular; 
}

void Control::SetModeAndOnlyExtruder(const bool is_one_extruder_printed_model, const int only_extruder)
{
    m_mode = !is_one_extruder_printed_model ? t_mode::MultiExtruder :
             only_extruder < 0              ? t_mode::SingleExtruder :
                                              t_mode::MultiAsSingle;
    if (!m_ticks.mode)
        m_ticks.mode = m_mode;
    m_only_extruder = only_extruder;

    UseDefaultColors(m_mode == t_mode::SingleExtruder);
}

void Control::SetExtruderColors( const std::vector<std::string>& extruder_colors)
{
    m_extruder_colors = extruder_colors;
}

void Control::get_lower_and_higher_position(int& lower_pos, int& higher_pos)
{
    const double step = get_scroll_step();
    if (is_horizontal()) {
        lower_pos = SLIDER_MARGIN + int(m_lower_value*step + 0.5);
        higher_pos = SLIDER_MARGIN + int(m_higher_value*step + 0.5);
    }
    else {
        lower_pos = SLIDER_MARGIN + int((m_max_value - m_lower_value)*step + 0.5);
        higher_pos = SLIDER_MARGIN + int((m_max_value - m_higher_value)*step + 0.5);
    }
}

void Control::draw_focus_rect()
{
    if (!m_is_focused) 
        return;
    const wxSize sz = GetSize();
    wxPaintDC dc(this);
    const wxPen pen = wxPen(wxColour(128, 128, 10), 1, wxPENSTYLE_DOT);
    dc.SetPen(pen);
    dc.SetBrush(wxBrush(wxColour(0, 0, 0), wxBRUSHSTYLE_TRANSPARENT));
    dc.DrawRectangle(1, 1, sz.x - 2, sz.y - 2);
}

void Control::render()
{
    SetBackgroundColour(GetParent()->GetBackgroundColour());
    draw_focus_rect();

    wxPaintDC dc(this);
    dc.SetFont(m_font);

    const wxCoord lower_pos = get_position_from_value(m_lower_value);
    const wxCoord higher_pos = get_position_from_value(m_higher_value);

    // draw colored band on the background of a scroll line 
    // and only in a case of no-empty m_values
    draw_colored_band(dc);

    // draw line
    draw_scroll_line(dc, lower_pos, higher_pos);

    //draw color print ticks
    draw_ticks(dc);

    // draw both sliders
    draw_thumbs(dc, lower_pos, higher_pos);

    //draw lock/unlock
    draw_one_layer_icon(dc);

    //draw revert bitmap (if it's shown)
    draw_revert_icon(dc);

    //draw cog bitmap (if it's shown)
    draw_cog_icon(dc);

    //draw mouse position
    draw_tick_on_mouse_position(dc);
}

void Control::draw_action_icon(wxDC& dc, const wxPoint pt_beg, const wxPoint pt_end)
{
    const int tick = m_selection == ssLower ? m_lower_value : m_higher_value;

    // suppress add tick on first layer
    if (tick == 0)
        return;

    wxBitmap* icon = m_focus == fiActionIcon ? &m_bmp_add_tick_off.bmp() : &m_bmp_add_tick_on.bmp();
    if (m_ticks.ticks.find(TickCode{tick}) != m_ticks.ticks.end())
        icon = m_focus == fiActionIcon ? &m_bmp_del_tick_off.bmp() : &m_bmp_del_tick_on.bmp();

    wxCoord x_draw, y_draw;
    is_horizontal() ? x_draw = pt_beg.x - 0.5*m_tick_icon_dim : y_draw = pt_beg.y - 0.5*m_tick_icon_dim;
    if (m_selection == ssLower)
        is_horizontal() ? y_draw = pt_end.y + 3 : x_draw = pt_beg.x - m_tick_icon_dim-2;
    else
        is_horizontal() ? y_draw = pt_beg.y - m_tick_icon_dim-2 : x_draw = pt_end.x + 3;

    dc.DrawBitmap(*icon, x_draw, y_draw);

    //update rect of the tick action icon
    m_rect_tick_action = wxRect(x_draw, y_draw, m_tick_icon_dim, m_tick_icon_dim);
}

void Control::draw_info_line_with_icon(wxDC& dc, const wxPoint& pos, const SelectedSlider selection)
{
    if (m_selection == selection) {
        //draw info line
        dc.SetPen(DARK_ORANGE_PEN);
        const wxPoint pt_beg = is_horizontal() ? wxPoint(pos.x, pos.y - m_thumb_size.y) : wxPoint(pos.x - m_thumb_size.x, pos.y/* - 1*/);
        const wxPoint pt_end = is_horizontal() ? wxPoint(pos.x, pos.y + m_thumb_size.y) : wxPoint(pos.x + m_thumb_size.x, pos.y/* - 1*/);
        dc.DrawLine(pt_beg, pt_end);

        //draw action icon
        if (m_draw_mode == dmRegular)
            draw_action_icon(dc, pt_beg, pt_end);
    }
}

void Control::draw_tick_on_mouse_position(wxDC& dc)
{
    if (!m_is_focused || m_moving_pos == wxDefaultPosition)
        return;

    //calculate thumb position on slider line
    int width, height;
    get_size(&width, &height);

    int tick = get_tick_near_point(m_moving_pos);
    if (tick == m_higher_value || tick == m_lower_value)
        return ;

    auto draw_ticks = [this](wxDC& dc, wxPoint pos, int margin=0 )
    {
        wxPoint pt_beg = is_horizontal() ? wxPoint(pos.x+margin, pos.y - m_thumb_size.y) : wxPoint(pos.x - m_thumb_size.x          , pos.y+margin);
        wxPoint pt_end = is_horizontal() ? wxPoint(pos.x+margin, pos.y + m_thumb_size.y) : wxPoint(pos.x - 0.5 * m_thumb_size.x + 1, pos.y+margin);
        dc.DrawLine(pt_beg, pt_end);

        pt_beg = is_horizontal() ? wxPoint(pos.x + margin, pos.y - m_thumb_size.y) : wxPoint(pos.x + 0.5 * m_thumb_size.x, pos.y+margin);
        pt_end = is_horizontal() ? wxPoint(pos.x + margin, pos.y + m_thumb_size.y) : wxPoint(pos.x + m_thumb_size.x + 1,   pos.y+margin);
        dc.DrawLine(pt_beg, pt_end);
    };

    auto draw_touch = [this](wxDC& dc, wxPoint pos, int margin, bool right_side )
    {
        int mult = right_side ? 1 : -1;
        wxPoint pt_beg = is_horizontal() ? wxPoint(pos.x - margin, pos.y + mult * m_thumb_size.y) : wxPoint(pos.x + mult * m_thumb_size.x, pos.y - margin);
        wxPoint pt_end = is_horizontal() ? wxPoint(pos.x + margin, pos.y + mult * m_thumb_size.y) : wxPoint(pos.x + mult * m_thumb_size.x, pos.y + margin);
        dc.DrawLine(pt_beg, pt_end);
    };

    if (tick > 0) // this tick exists and should be marked as a focused
    {
        wxCoord new_pos = get_position_from_value(tick);
        const wxPoint pos = is_horizontal() ? wxPoint(new_pos, height * 0.5) : wxPoint(0.5 * width, new_pos);

        dc.SetPen(DARK_ORANGE_PEN);

        draw_ticks(dc, pos, -2);
        draw_ticks(dc, pos, 2 );
        draw_touch(dc, pos, 2, true);
        draw_touch(dc, pos, 2, false);

        return;
    }

    tick = get_value_from_position(m_moving_pos);
    if (tick >= m_max_value || tick <= m_min_value || tick == m_higher_value || tick == m_lower_value)
        return;

    wxCoord new_pos = get_position_from_value(tick);
    const wxPoint pos = is_horizontal() ? wxPoint(new_pos, height * 0.5) : wxPoint(0.5 * width, new_pos);

    //draw info line
    dc.SetPen(LIGHT_GREY_PEN);
    draw_ticks(dc, pos);
}

wxString Control::get_label(int tick) const
{
    const int value = tick;

    if (m_label_koef == 1.0 && m_values.empty())
        return wxString::Format("%d", value);
    if (value >= m_values.size())
        return "ErrVal";

    const wxString str = m_values.empty() ? 
                         wxNumberFormatter::ToString(m_label_koef*value, 2, wxNumberFormatter::Style_None) :
                         wxNumberFormatter::ToString(m_values[value], 2, wxNumberFormatter::Style_None);
    return from_u8((boost::format("%1%\n(%2%)") % str % (m_values.empty() ? value : value+1)).str());
}

void Control::draw_tick_text(wxDC& dc, const wxPoint& pos, int tick, bool right_side/*=true*/) const
{
    wxCoord text_width, text_height;
    const wxString label = get_label(tick);
    dc.GetMultiLineTextExtent(label, &text_width, &text_height);
    wxPoint text_pos;
    if (right_side)
        text_pos = is_horizontal() ? wxPoint(pos.x + 1, pos.y + m_thumb_size.x) :
                   wxPoint(pos.x + m_thumb_size.x+1, pos.y - 0.5*text_height - 1);
    else
        text_pos = is_horizontal() ? wxPoint(pos.x - text_width - 1, pos.y - m_thumb_size.x - text_height) :
                   wxPoint(pos.x - text_width - 1 - m_thumb_size.x, pos.y - 0.5*text_height + 1);
   dc.DrawText(label, text_pos);
}

void Control::draw_thumb_text(wxDC& dc, const wxPoint& pos, const SelectedSlider& selection) const
{
    draw_tick_text(dc, pos, selection == ssLower ? m_lower_value : m_higher_value, selection == ssLower);
}

void Control::draw_thumb_item(wxDC& dc, const wxPoint& pos, const SelectedSlider& selection)
{
    wxCoord x_draw, y_draw;
    if (selection == ssLower) {
        if (is_horizontal()) {
            x_draw = pos.x - m_thumb_size.x;
            y_draw = pos.y - int(0.5*m_thumb_size.y);
        }
        else {
            x_draw = pos.x - int(0.5*m_thumb_size.x);
            y_draw = pos.y - int(0.5*m_thumb_size.y);
        }
    }
    else{
        if (is_horizontal()) {
            x_draw = pos.x;
            y_draw = pos.y - int(0.5*m_thumb_size.y);
        }
        else {
            x_draw = pos.x - int(0.5*m_thumb_size.x);
            y_draw = pos.y - int(0.5*m_thumb_size.y);
        }
    }
    dc.DrawBitmap(selection == ssLower ? m_bmp_thumb_lower.bmp() : m_bmp_thumb_higher.bmp(), x_draw, y_draw);

    // Update thumb rect
    update_thumb_rect(x_draw, y_draw, selection);
}

void Control::draw_thumb(wxDC& dc, const wxCoord& pos_coord, const SelectedSlider& selection)
{
    //calculate thumb position on slider line
    int width, height;
    get_size(&width, &height);
    const wxPoint pos = is_horizontal() ? wxPoint(pos_coord, height*0.5) : wxPoint(0.5*width, pos_coord);

    // Draw thumb
    draw_thumb_item(dc, pos, selection);

    // Draw info_line
    draw_info_line_with_icon(dc, pos, selection);

    // Draw thumb text
    draw_thumb_text(dc, pos, selection);
}

void Control::draw_thumbs(wxDC& dc, const wxCoord& lower_pos, const wxCoord& higher_pos)
{
    //calculate thumb position on slider line
    int width, height;
    get_size(&width, &height);
    const wxPoint pos_l = is_horizontal() ? wxPoint(lower_pos, height*0.5) : wxPoint(0.5*width, lower_pos);
    const wxPoint pos_h = is_horizontal() ? wxPoint(higher_pos, height*0.5) : wxPoint(0.5*width, higher_pos);

    // Draw lower thumb
    draw_thumb_item(dc, pos_l, ssLower);
    // Draw lower info_line
    draw_info_line_with_icon(dc, pos_l, ssLower);

    // Draw higher thumb
    draw_thumb_item(dc, pos_h, ssHigher);
    // Draw higher info_line
    draw_info_line_with_icon(dc, pos_h, ssHigher);
    // Draw higher thumb text
    draw_thumb_text(dc, pos_h, ssHigher);

    // Draw lower thumb text
    draw_thumb_text(dc, pos_l, ssLower);
}

void Control::draw_ticks(wxDC& dc)
{
    if (m_draw_mode == dmSlaPrint)
        return;

    dc.SetPen(m_draw_mode == dmRegular ? DARK_GREY_PEN : LIGHT_GREY_PEN );
    int height, width;
    get_size(&width, &height);
    const wxCoord mid = is_horizontal() ? 0.5*height : 0.5*width;
    for (auto tick : m_ticks.ticks)
    {
        const wxCoord pos = get_position_from_value(tick.tick);

        is_horizontal() ?   dc.DrawLine(pos, mid-14, pos, mid-9) :
                            dc.DrawLine(mid - 14, pos/* - 1*/, mid - 9, pos/* - 1*/);
        is_horizontal() ?   dc.DrawLine(pos, mid+14, pos, mid+9) :
                            dc.DrawLine(mid + 14, pos/* - 1*/, mid + 9, pos/* - 1*/);

        // if current tick if focused, we should to use a specific "focused" icon 
        bool focused_tick = m_moving_pos != wxDefaultPosition && tick.tick == get_tick_near_point(m_moving_pos);

        // get icon name if it is
        std::string icon_name;

        // if we have non-regular draw mode, all ticks should be marked with error icon
        if (m_draw_mode != dmRegular)
            icon_name = focused_tick ? "error_tick_f" : "error_tick";
        else if (tick.gcode == ColorChangeCode || tick.gcode == ToolChangeCode) { 
            if (m_ticks.is_conflict_tick(tick, m_mode, m_only_extruder, m_values[tick.tick]))
                icon_name = focused_tick ? "error_tick_f" : "error_tick";
        }
        else if (tick.gcode == PausePrintCode)
            icon_name = focused_tick ? "pause_print_f" : "pause_print";
        else
            icon_name = focused_tick ? "edit_gcode_f" : "edit_gcode";

        // Draw icon for "Pause print", "Custom Gcode" or conflict tick
        if (!icon_name.empty()) 
        {
            wxBitmap icon = create_scaled_bitmap(icon_name);
            wxCoord x_draw, y_draw;
            is_horizontal() ? x_draw = pos - 0.5 * m_tick_icon_dim : y_draw = pos - 0.5 * m_tick_icon_dim;
            is_horizontal() ? y_draw = mid + 22 : x_draw = mid + m_thumb_size.x + 3;

            dc.DrawBitmap(icon, x_draw, y_draw);
        }
    }
}

std::string Control::get_color_for_tool_change_tick(std::set<TickCode>::const_iterator it) const
{
    const int current_extruder = it->extruder == 0 ? std::max<int>(m_only_extruder, 1) : it->extruder;

    auto it_n = it;
    while (it_n != m_ticks.ticks.begin()) {
        --it_n;
        if (it_n->gcode == ColorChangeCode && it_n->extruder == current_extruder)
            return it_n->color;
    }

    return m_extruder_colors[current_extruder-1]; // return a color for a specific extruder from the colors list 
}

std::string Control::get_color_for_color_change_tick(std::set<TickCode>::const_iterator it) const
{
    const int def_extruder = std::max<int>(1, m_only_extruder);
    auto it_n = it;
    bool is_tool_change = false;
    while (it_n != m_ticks.ticks.begin()) {
        --it_n;
        if (it_n->gcode == ToolChangeCode) {
            is_tool_change = true;
            if (it_n->extruder == it->extruder)
                return it->color;
            break;
        }
        if (it_n->gcode == ColorChangeCode && it_n->extruder == it->extruder)
            return it->color;
    }
    if (!is_tool_change && it->extruder == def_extruder)
        return it->color;

    return "";
}

wxRect Control::get_colored_band_rect()
{
    int height, width;
    get_size(&width, &height);

    const wxCoord mid = is_horizontal() ? 0.5 * height : 0.5 * width;

    return is_horizontal() ?
           wxRect(SLIDER_MARGIN, lround(mid - 0.375 * m_thumb_size.y), 
                  width - 2 * SLIDER_MARGIN + 1, lround(0.75 * m_thumb_size.y)) :
           wxRect(lround(mid - 0.375 * m_thumb_size.x), SLIDER_MARGIN, 
                  lround(0.75 * m_thumb_size.x), height - 2 * SLIDER_MARGIN + 1);
}

void Control::draw_colored_band(wxDC& dc)
{
    if (m_draw_mode != dmRegular)
        return;

    auto draw_band = [](wxDC& dc, const wxColour& clr, const wxRect& band_rc) 
    {
        dc.SetPen(clr);
        dc.SetBrush(clr);
        dc.DrawRectangle(band_rc);
    };

    wxRect main_band = get_colored_band_rect();

    // don't color a band for MultiExtruder mode
    if (m_ticks.empty() || m_mode == t_mode::MultiExtruder)
    {
        draw_band(dc, GetParent()->GetBackgroundColour(), main_band);
        return;
    }

    const int default_color_idx = m_mode==t_mode::MultiAsSingle ? std::max<int>(m_only_extruder - 1, 0) : 0;
    draw_band(dc, wxColour(m_extruder_colors[default_color_idx]), main_band);

    std::set<TickCode>::const_iterator tick_it = m_ticks.ticks.begin();

    while (tick_it != m_ticks.ticks.end())
    {
        if ( (m_mode == t_mode::SingleExtruder &&  tick_it->gcode == ColorChangeCode  ) ||
             (m_mode == t_mode::MultiAsSingle  && (tick_it->gcode == ToolChangeCode || tick_it->gcode == ColorChangeCode)) ) 
        {        
            const wxCoord pos = get_position_from_value(tick_it->tick);
            is_horizontal() ? main_band.SetLeft(SLIDER_MARGIN + pos) :
                              main_band.SetBottom(pos - 1);

            const std::string clr_str = m_mode == t_mode::SingleExtruder ? tick_it->color :
                                        tick_it->gcode == ToolChangeCode ?
                                        get_color_for_tool_change_tick(tick_it) :
                                        get_color_for_color_change_tick(tick_it);

            if (!clr_str.empty())
                draw_band(dc, wxColour(clr_str), main_band);
        }
        ++tick_it;
    }
}

void Control::draw_one_layer_icon(wxDC& dc)
{
    const wxBitmap& icon = m_is_one_layer ?
                     m_focus == fiOneLayerIcon ? m_bmp_one_layer_lock_off.bmp()   : m_bmp_one_layer_lock_on.bmp() :
                     m_focus == fiOneLayerIcon ? m_bmp_one_layer_unlock_off.bmp() : m_bmp_one_layer_unlock_on.bmp();

    int width, height;
    get_size(&width, &height);

    wxCoord x_draw, y_draw;
    is_horizontal() ? x_draw = width-2 : x_draw = 0.5*width - 0.5*m_lock_icon_dim;
    is_horizontal() ? y_draw = 0.5*height - 0.5*m_lock_icon_dim : y_draw = height-2;

    dc.DrawBitmap(icon, x_draw, y_draw);

    //update rect of the lock/unlock icon
    m_rect_one_layer_icon = wxRect(x_draw, y_draw, m_lock_icon_dim, m_lock_icon_dim);
}

void Control::draw_revert_icon(wxDC& dc)
{
    if (m_ticks.empty() || m_draw_mode != dmRegular)
        return;

    int width, height;
    get_size(&width, &height);

    wxCoord x_draw, y_draw;
    is_horizontal() ? x_draw = width-2 : x_draw = 0.25*SLIDER_MARGIN;
    is_horizontal() ? y_draw = 0.25*SLIDER_MARGIN: y_draw = height-2;

    dc.DrawBitmap(m_bmp_revert.bmp(), x_draw, y_draw);

    //update rect of the lock/unlock icon
    m_rect_revert_icon = wxRect(x_draw, y_draw, m_revert_icon_dim, m_revert_icon_dim);
}

void Control::draw_cog_icon(wxDC& dc)
{
    int width, height;
    get_size(&width, &height);

    wxCoord x_draw, y_draw;
    is_horizontal() ? x_draw = width-2 : x_draw = width - m_cog_icon_dim - 2;
    is_horizontal() ? y_draw = height - m_cog_icon_dim - 2 : y_draw = height-2;

    dc.DrawBitmap(m_bmp_cog.bmp(), x_draw, y_draw);

    //update rect of the lock/unlock icon
    m_rect_cog_icon = wxRect(x_draw, y_draw, m_cog_icon_dim, m_cog_icon_dim);
}

void Control::update_thumb_rect(const wxCoord& begin_x, const wxCoord& begin_y, const SelectedSlider& selection)
{
    const wxRect& rect = wxRect(begin_x, begin_y + (selection == ssLower ? int(m_thumb_size.y * 0.5) : 0), m_thumb_size.x, int(m_thumb_size.y*0.5));
    if (selection == ssLower)
        m_rect_lower_thumb = rect;
    else
        m_rect_higher_thumb = rect;
}

int Control::get_value_from_position(const wxCoord x, const wxCoord y)
{
    const int height = get_size().y;
    const double step = get_scroll_step();
    
    if (is_horizontal()) 
        return int(double(x - SLIDER_MARGIN) / step + 0.5);

    return int(m_min_value + double(height - SLIDER_MARGIN - y) / step + 0.5);
}

bool Control::detect_selected_slider(const wxPoint& pt)
{
    if (is_point_in_rect(pt, m_rect_lower_thumb))
        m_selection = ssLower;
    else if(is_point_in_rect(pt, m_rect_higher_thumb))
        m_selection = ssHigher;
    else
        return false; // pt doesn't referenced to any thumb 
    return true;
}

bool Control::is_point_in_rect(const wxPoint& pt, const wxRect& rect)
{
    return  rect.GetLeft() <= pt.x && pt.x <= rect.GetRight() && 
            rect.GetTop()  <= pt.y && pt.y <= rect.GetBottom();
}

int Control::get_tick_near_point(const wxPoint& pt)
{
    for (auto tick : m_ticks.ticks) {
        const wxCoord pos = get_position_from_value(tick.tick);

        if (is_horizontal()) {
            if (pos - 4 <= pt.x && pt.x <= pos + 4)
                return tick.tick;
        }
        else {
            if (pos - 4 <= pt.y && pt.y <= pos + 4) 
                return tick.tick;
        }
    }
    return -1;
}

void Control::ChangeOneLayerLock()
{
    m_is_one_layer = !m_is_one_layer;
    m_selection == ssLower ? correct_lower_value() : correct_higher_value();
    if (!m_selection) m_selection = ssHigher;

    Refresh();
    Update();

    wxCommandEvent e(wxEVT_SCROLL_CHANGED);
    e.SetEventObject(this);
    ProcessWindowEvent(e);
}

void Control::OnLeftDown(wxMouseEvent& event)
{
    if (HasCapture())
        return;
    this->CaptureMouse();

    m_is_left_down = true;
    m_mouse = maNone;

    wxPoint pos = event.GetLogicalPosition(wxClientDC(this));

    if (is_point_in_rect(pos, m_rect_one_layer_icon)) 
        m_mouse = maOneLayerIconClick;
    else if (is_point_in_rect(pos, m_rect_cog_icon))
        m_mouse = maCogIconClick;
    else if (m_draw_mode == dmRegular)
    {
        if (is_point_in_rect(pos, m_rect_tick_action)) {
            auto it = m_ticks.ticks.find(TickCode{ m_selection == ssLower ? m_lower_value : m_higher_value });
            m_mouse = it == m_ticks.ticks.end() ? maAddTick : maDeleteTick;
        }
        else if (is_point_in_rect(pos, m_rect_revert_icon))
            m_mouse = maRevertIconClick;
    }

    if (m_mouse == maNone)
        detect_selected_slider(pos);

    event.Skip();
}

void Control::correct_lower_value()
{
    if (m_lower_value < m_min_value)
        m_lower_value = m_min_value;
    else if (m_lower_value > m_max_value)
        m_lower_value = m_max_value;
    
    if ((m_lower_value >= m_higher_value && m_lower_value <= m_max_value) || m_is_one_layer)
        m_higher_value = m_lower_value;
}

void Control::correct_higher_value()
{
    if (m_higher_value > m_max_value)
        m_higher_value = m_max_value;
    else if (m_higher_value < m_min_value)
        m_higher_value = m_min_value;
    
    if ((m_higher_value <= m_lower_value && m_higher_value >= m_min_value) || m_is_one_layer)
        m_lower_value = m_higher_value;
}

wxString Control::get_tooltip(int tick/*=-1*/)
{
    if (m_focus == fiNone)
        return "";
    if (m_focus == fiOneLayerIcon)
        return _(L("One layer mode"));
    if (m_focus == fiRevertIcon)
        return _(L("Discard all custom changes"));
    if (m_focus == fiCogIcon)
        return m_mode == t_mode::MultiAsSingle                                                              ?
               GUI::from_u8((boost::format(_utf8(L("Jump to height %s or "
                                       "Set extruder sequence for the entire print"))) % " (Shift + G)\n").str()) :
               _(L("Jump to height")) + " (Shift + G)";
    if (m_focus == fiColorBand)
        return m_mode != t_mode::SingleExtruder ? "" :
               _(L("Edit current color - Right click the colored slider segment"));
    if (m_draw_mode == dmSlaPrint)
        return ""; // no drawn ticks and no tooltips for them in SlaPrinting mode

    wxString tooltip;
    const auto tick_code_it = m_ticks.ticks.find(TickCode{tick});

    if (tick_code_it == m_ticks.ticks.end() && m_focus == fiActionIcon)    // tick doesn't exist
    {
        // Show mode as a first string of tooltop
        tooltip = "    " + _(L("Print mode")) + ": ";
        tooltip += (m_mode == t_mode::SingleExtruder ? CustomGCode::SingleExtruderMode :
                    m_mode == t_mode::MultiAsSingle  ? CustomGCode::MultiAsSingleMode  :
                    CustomGCode::MultiExtruderMode );
        tooltip += "\n\n";

        /* Note: just on OSX!!!
         * Right click event causes a little scrolling.
         * So, as a workaround we use Ctrl+LeftMouseClick instead of RightMouseClick
         * Show this information in tooltip
         * */

        // Show list of actions with new tick
        tooltip += ( m_mode == t_mode::MultiAsSingle                            ?
                  _(L("Add extruder change - Left click"))                      :
                     m_mode == t_mode::SingleExtruder                           ?
                  _(L("Add color change - Left click for predefined color or "
                      "Shift + Left click for custom color selection"))         :
                  _(L("Add color change - Left click"))  ) + " " +
                  _(L("or press \"+\" key")) + "\n" + (
                      is_osx ? 
                  _(L("Add another code - Ctrl + Left click")) :
                  _(L("Add another code - Right click")) );
    }

    if (tick_code_it != m_ticks.ticks.end())                                    // tick exists
    {
        if (m_draw_mode == dmSequentialFffPrint)
            return  _(L("The sequential print is on.\n"
                        "It's impossible to apply any custom G-code for objects printing sequentually.\n" 
                        "This code won't be processed during G-code generation."));

        // Show custom Gcode as a first string of tooltop
        tooltip = "    ";
        tooltip +=  tick_code_it->gcode == ColorChangeCode ?    (   m_mode == t_mode::SingleExtruder                ? 
                        from_u8((boost::format(_utf8(L("Color change (\"%1%\")"))) % tick_code_it->gcode ).str()) :
                        from_u8((boost::format(_utf8(L("Color change (\"%1%\") for Extruder %2%"))) % 
                                               tick_code_it->gcode % tick_code_it->extruder).str()) )                   :
                    tick_code_it->gcode == PausePrintCode ?
                        from_u8((boost::format(_utf8(L("Pause print (\"%1%\")"))) % tick_code_it->gcode ).str())      :
                    tick_code_it->gcode == ToolChangeCode ?
                        from_u8((boost::format(_utf8(L("Extruder (tool) is changed to Extruder \"%1%\""))) % 
                                               tick_code_it->extruder ).str())                                          :
                        from_u8(tick_code_it->gcode);

        // If tick is marked as a conflict (exclamation icon),
        // we should to explain why
        ConflictType conflict = m_ticks.is_conflict_tick(*tick_code_it, m_mode, m_only_extruder, m_values[tick]);
        if (conflict != ctNone)
            tooltip += "\n\n" + _(L("Note")) + "! ";
        if (conflict == ctModeConflict)
            tooltip +=  _(L("G-code associated to this tick mark is in a conflict with print mode.\n"
                            "Editing it will cause changes of Slider data."));
        else if (conflict == ctMeaninglessColorChange)
            tooltip +=  _(L("There is a color change for extruder that won't be used till the end of print job.\n"
                            "This code won't be processed during G-code generation."));
        else if (conflict == ctMeaninglessToolChange)
            tooltip +=  _(L("There is an extruder change set to the same extruder.\n"
                            "This code won't be processed during G-code generation."));
        else if (conflict == ctRedundant)
            tooltip +=  _(L("There is a color change for extruder that has not been used before.\n"
                            "Check your settings to avoid redundant color changes."));

        // Show list of actions with existing tick
        if (m_focus == fiActionIcon)
        tooltip += "\n\n" + _(L("Delete tick mark - Left click or press \"-\" key")) + "\n" + (
                      is_osx ? 
                   _(L("Edit tick mark - Ctrl + Left click")) :
                   _(L("Edit tick mark - Right click")) );
    }
    return tooltip;

}

int Control::get_edited_tick_for_position(const wxPoint pos, const std::string& gcode /*= ColorChangeCode*/)
{
    if (m_ticks.empty())
        return -1;

    int tick = get_value_from_position(pos);
    auto it = std::lower_bound(m_ticks.ticks.begin(), m_ticks.ticks.end(), TickCode{ tick });

    while (it != m_ticks.ticks.begin()) {
        --it;
        if (it->gcode == gcode)
            return it->tick;
    }

    return -1;
}

void Control::OnMotion(wxMouseEvent& event)
{
    bool action = false;

    const wxPoint pos = event.GetLogicalPosition(wxClientDC(this));
    int tick = -1;

    if (!m_is_left_down && !m_is_right_down) 
    {
        if (is_point_in_rect(pos, m_rect_one_layer_icon))
            m_focus = fiOneLayerIcon;
        else if (is_point_in_rect(pos, m_rect_tick_action)) {
            m_focus = fiActionIcon;
            tick = m_selection == ssLower ? m_lower_value : m_higher_value;
        }
        else if (!m_ticks.empty() && is_point_in_rect(pos, m_rect_revert_icon))
            m_focus = fiRevertIcon;
        else if (is_point_in_rect(pos, m_rect_cog_icon))
            m_focus = fiCogIcon;
        else if (m_mode == t_mode::SingleExtruder && is_point_in_rect(pos, get_colored_band_rect()) &&
                 get_edited_tick_for_position(pos) >= 0 )
            m_focus = fiColorBand;
        else {
            m_focus = fiTick;
            tick = get_tick_near_point(pos);
        }
        m_moving_pos = pos;
    }
    else if (m_is_left_down || m_is_right_down) {
        if (m_selection == ssLower) {
            int current_value = m_lower_value;
            m_lower_value = get_value_from_position(pos.x, pos.y);
            correct_lower_value();
            action = (current_value != m_lower_value);
        }
        else if (m_selection == ssHigher) {
            int current_value = m_higher_value;
            m_higher_value = get_value_from_position(pos.x, pos.y);
            correct_higher_value();
            action = (current_value != m_higher_value);
        }
        m_moving_pos = wxDefaultPosition;
    }
    Refresh();
    Update();
    event.Skip();

    // Set tooltips with information for each icon
    this->SetToolTip(get_tooltip(tick));

    if (action)
    {
        wxCommandEvent e(wxEVT_SCROLL_CHANGED);
        e.SetEventObject(this);
        e.SetString("moving");
        ProcessWindowEvent(e);
    }
}

void Control::append_change_extruder_menu_item(wxMenu* menu, bool switch_current_code/* = false*/)
{
    const int extruders_cnt = GUI::wxGetApp().extruders_edited_cnt();
    if (extruders_cnt > 1)
    {
        std::array<int, 2> active_extruders = get_active_extruders_for_tick(m_selection == ssLower ? m_lower_value : m_higher_value);

        std::vector<wxBitmap*> icons = get_extruder_color_icons(true);

        wxMenu* change_extruder_menu = new wxMenu();

        for (int i = 1; i <= extruders_cnt; i++)
        {
            const bool is_active_extruder = i == active_extruders[0] || i == active_extruders[1];
            const wxString item_name = wxString::Format(_(L("Extruder %d")), i) +
                                       (is_active_extruder ? " (" + _(L("active")) + ")" : "");

            if (m_mode == t_mode::MultiAsSingle)
                append_menu_item(change_extruder_menu, wxID_ANY, item_name, "",
                    [this, i](wxCommandEvent&) { add_code_as_tick(ToolChangeCode, i); }, *icons[i-1], menu,
                    [is_active_extruder]() { return !is_active_extruder; }, GUI::wxGetApp().plater());
        }

        const wxString change_extruder_menu_name = m_mode == t_mode::MultiAsSingle ? 
                                                   (switch_current_code ? _(L("Switch code to Change extruder")) : _(L("Change extruder")) ) : 
                                                   _(L("Change extruder (N/A)"));

        wxMenuItem* change_extruder_menu_item = menu->AppendSubMenu(change_extruder_menu, change_extruder_menu_name, _(L("Use another extruder")));
        change_extruder_menu_item->SetBitmap(create_scaled_bitmap(active_extruders[1] > 0 ? "edit_uni" : "change_extruder"));

        GUI::wxGetApp().plater()->Bind(wxEVT_UPDATE_UI, [this, change_extruder_menu_item](wxUpdateUIEvent& evt) {
            enable_menu_item(evt, [this]() {return m_mode == t_mode::MultiAsSingle; }, change_extruder_menu_item, this); },
            change_extruder_menu_item->GetId());
    }
}

void Control::append_add_color_change_menu_item(wxMenu* menu, bool switch_current_code/* = false*/)
{
    const int extruders_cnt = GUI::wxGetApp().extruders_edited_cnt();
    if (extruders_cnt > 1)
    {
        int tick = m_selection == ssLower ? m_lower_value : m_higher_value; 
        std::set<int> used_extruders_for_tick = m_ticks.get_used_extruders_for_tick(tick, m_only_extruder, m_values[tick]);

        wxMenu* add_color_change_menu = new wxMenu();

        for (int i = 1; i <= extruders_cnt; i++)
        {
            const bool is_used_extruder = used_extruders_for_tick.empty() ? true : // #ys_FIXME till used_extruders_for_tick doesn't filled correct for mmMultiExtruder
                                          used_extruders_for_tick.find(i) != used_extruders_for_tick.end();
            const wxString item_name = wxString::Format(_(L("Extruder %d")), i) +
                                       (is_used_extruder ? " (" + _(L("used")) + ")" : "");

            append_menu_item(add_color_change_menu, wxID_ANY, item_name, "",
                [this, i](wxCommandEvent&) { add_code_as_tick(ColorChangeCode, i); }, "", menu,
                []() { return true; }, GUI::wxGetApp().plater());
        }

        const wxString menu_name = switch_current_code ? 
                                   from_u8((boost::format(_utf8(L("Switch code to Color change (%1%) for:"))) % ColorChangeCode).str()) : 
                                   from_u8((boost::format(_utf8(L("Add color change (%1%) for:"))) % ColorChangeCode).str());
        wxMenuItem* add_color_change_menu_item = menu->AppendSubMenu(add_color_change_menu, menu_name, "");
        add_color_change_menu_item->SetBitmap(create_scaled_bitmap("colorchange_add_m"));
    }
}

void Control::OnLeftUp(wxMouseEvent& event)
{
    if (!HasCapture())
        return;
    this->ReleaseMouse();
    m_is_left_down = false;

    switch (m_mouse) {
    case maNone :
        move_current_thumb_to_pos(event.GetLogicalPosition(wxClientDC(this)));
        break;
    case maDeleteTick : 
        delete_current_tick();
        break;
    case maAddTick :
        add_current_tick();
        break;
    case maCogIconClick :
        if (m_mode == t_mode::MultiAsSingle && m_draw_mode == dmRegular)
            show_cog_icon_context_menu();
        else
            jump_to_print_z();
        break;
    case maOneLayerIconClick:
        switch_one_layer_mode();
        break;
    case maRevertIconClick:
        discard_all_thicks();
        break;
    default :
        break;
    }

    Refresh();
    Update();
    event.Skip();

    wxCommandEvent e(wxEVT_SCROLL_CHANGED);
    e.SetEventObject(this);
    ProcessWindowEvent(e);
}

void Control::enter_window(wxMouseEvent& event, const bool enter)
{
    m_is_focused = enter;
    Refresh();
    Update();
    event.Skip();
}

// "condition" have to be true for:
//    -  value increase (if wxSL_VERTICAL)
//    -  value decrease (if wxSL_HORIZONTAL) 
void Control::move_current_thumb(const bool condition)
{
//     m_is_one_layer = wxGetKeyState(WXK_CONTROL);
    int delta = condition ? -1 : 1;
    if (is_horizontal())
        delta *= -1;

    if (m_selection == ssLower) {
        m_lower_value -= delta;
        correct_lower_value();
    }
    else if (m_selection == ssHigher) {
        m_higher_value -= delta;
        correct_higher_value();
    }
    Refresh();
    Update();

    wxCommandEvent e(wxEVT_SCROLL_CHANGED);
    e.SetEventObject(this);
    ProcessWindowEvent(e);
}

void Control::OnWheel(wxMouseEvent& event)
{
    // Set nearest to the mouse thumb as a selected, if there is not selected thumb
    if (m_selection == ssUndef) 
    {
        const wxPoint& pt = event.GetLogicalPosition(wxClientDC(this));
        
        if (is_horizontal())
            m_selection = abs(pt.x - m_rect_lower_thumb.GetRight()) <= 
                          abs(pt.x - m_rect_higher_thumb.GetLeft()) ? 
                          ssLower : ssHigher;
        else
            m_selection = abs(pt.y - m_rect_lower_thumb.GetTop()) <= 
                          abs(pt.y - m_rect_higher_thumb.GetBottom()) ? 
                          ssLower : ssHigher;
    }

    move_current_thumb(event.GetWheelRotation() > 0);
}

void Control::OnKeyDown(wxKeyEvent &event)
{
    const int key = event.GetKeyCode();
    if (key == WXK_NUMPAD_ADD) {
        // OnChar() is called immediately after OnKeyDown(), which can cause call of add_tick() twice.
        // To avoid this case we should suppress second add_tick() call.
        m_ticks.suppress_plus(true);
        add_current_tick(true);
    }
    else if (key == 390 || key == WXK_DELETE || key == WXK_BACK) {
        // OnChar() is called immediately after OnKeyDown(), which can cause call of delete_tick() twice.
        // To avoid this case we should suppress second delete_tick() call.
        m_ticks.suppress_minus(true);
        delete_current_tick();
    }
    else if (event.GetKeyCode() == WXK_SHIFT)
        UseDefaultColors(false);
    else if (is_horizontal())
    {
        if (key == WXK_LEFT || key == WXK_RIGHT)
            move_current_thumb(key == WXK_LEFT); 
        else if (key == WXK_UP || key == WXK_DOWN) {
            m_selection = key == WXK_UP ? ssHigher : ssLower;
            Refresh();
        }
    }
    else {
        if (key == WXK_LEFT || key == WXK_RIGHT) {
            m_selection = key == WXK_LEFT ? ssHigher : ssLower;
            Refresh();
        }
        else if (key == WXK_UP || key == WXK_DOWN)
            move_current_thumb(key == WXK_UP);
    }

    event.Skip(); // !Needed to have EVT_CHAR generated as well
}

void Control::OnKeyUp(wxKeyEvent &event)
{
    if (event.GetKeyCode() == WXK_CONTROL)
        m_is_one_layer = false;
    else if (event.GetKeyCode() == WXK_SHIFT)
        UseDefaultColors(true);

    Refresh();
    Update();
    event.Skip();
}

void Control::OnChar(wxKeyEvent& event)
{
    const int key = event.GetKeyCode();
    if (key == '+' && !m_ticks.suppressed_plus()) {
        add_current_tick(true);
        m_ticks.suppress_plus(false);
    }
    else if (key == '-' && !m_ticks.suppressed_minus()) {
        delete_current_tick();
        m_ticks.suppress_minus(false);
    }
    if (key == 'G')
        jump_to_print_z();
}

void Control::OnRightDown(wxMouseEvent& event)
{
    if (HasCapture()) return;
    this->CaptureMouse();

    const wxPoint pos = event.GetLogicalPosition(wxClientDC(this));

    m_mouse = maNone;
    if (m_draw_mode == dmRegular) {
        if (is_point_in_rect(pos, m_rect_tick_action))
        {
            const int tick = m_selection == ssLower ? m_lower_value : m_higher_value;
            m_mouse = m_ticks.ticks.find(TickCode{ tick }) == m_ticks.ticks.end() ?
                             maAddMenu : maEditMenu;
        }
        else if (m_mode == t_mode::SingleExtruder   && !detect_selected_slider(pos) && is_point_in_rect(pos, get_colored_band_rect()))
            m_mouse = maForceColorEdit;
        else if (m_mode == t_mode::MultiAsSingle    && is_point_in_rect(pos, m_rect_cog_icon))
            m_mouse = maCogIconMenu;
    }
    if (m_mouse != maNone || !detect_selected_slider(pos))
        return;

    if (m_selection == ssLower)
        m_higher_value = m_lower_value;
    else
        m_lower_value = m_higher_value;

    // set slider to "one layer" mode
    m_is_right_down = m_is_one_layer = true; 

    Refresh();
    Update();
    event.Skip();
}

// Get active extruders for tick. 
// Means one current extruder for not existing tick OR 
// 2 extruders - for existing tick (extruder before ToolChangeCode and extruder of current existing tick)
// Use those values to disable selection of active extruders
std::array<int, 2> Control::get_active_extruders_for_tick(int tick) const
{
    int default_initial_extruder = m_mode == t_mode::MultiAsSingle ? std::max<int>(1, m_only_extruder) : 1;
    std::array<int, 2> extruders = { default_initial_extruder, -1 };
    if (m_ticks.empty())
        return extruders;

    auto it = m_ticks.ticks.lower_bound(TickCode{tick});

    if (it != m_ticks.ticks.end() && it->tick == tick) // current tick exists
        extruders[1] = it->extruder;

    while (it != m_ticks.ticks.begin()) {
        --it;
        if(it->gcode == ToolChangeCode) {
            extruders[0] = it->extruder;
            break;
        }
    }

    return extruders;
}

// Get used extruders for tick. 
// Means all extruders(tools) which will be used during printing from current tick to the end
std::set<int> TickCodeInfo::get_used_extruders_for_tick(int tick, int only_extruder, double print_z, t_mode force_mode/* = t_mode::Undef*/) const
{
    t_mode e_mode = !force_mode ? mode : force_mode;

    if (e_mode == t_mode::MultiExtruder)
    {
        // #ys_FIXME: get tool ordering from _correct_ place
        const ToolOrdering& tool_ordering = GUI::wxGetApp().plater()->fff_print().get_tool_ordering();

        if (tool_ordering.empty())
            return {};

        std::set<int> used_extruders;

        auto it_layer_tools = std::lower_bound(tool_ordering.begin(), tool_ordering.end(), LayerTools(print_z));
        for (; it_layer_tools != tool_ordering.end(); ++it_layer_tools)
        {
            const std::vector<unsigned>& extruders = it_layer_tools->extruders;
            for (const auto& extruder : extruders)
                used_extruders.emplace(extruder+1);
        }

        return used_extruders;
    }

    const int default_initial_extruder = e_mode == t_mode::MultiAsSingle ? std::max(only_extruder, 1) : 1;
    if (ticks.empty() || e_mode == t_mode::SingleExtruder)
        return {default_initial_extruder};

    std::set<int> used_extruders;

    auto it_start = ticks.lower_bound(TickCode{tick});
    auto it = it_start;
    if (it == ticks.begin() && it->gcode == ToolChangeCode &&
        tick != it->tick )  // In case of switch of ToolChange to ColorChange, when tick exists,
                            // we shouldn't change color for extruder, which will be deleted
    {
        used_extruders.emplace(it->extruder);
        if (tick < it->tick)
            used_extruders.emplace(default_initial_extruder);
    }

    while (it != ticks.begin()) {
        --it;
        if (it->gcode == ToolChangeCode && tick != it->tick) {
            used_extruders.emplace(it->extruder);
            break;
        }
    }

    if (it == ticks.begin() && used_extruders.empty())
        used_extruders.emplace(default_initial_extruder);

    for (it = it_start; it != ticks.end(); ++it)
        if (it->gcode == ToolChangeCode && tick != it->tick)
            used_extruders.emplace(it->extruder);

    return used_extruders;
}

void Control::show_add_context_menu()
{
    wxMenu menu;

    if (m_mode == t_mode::SingleExtruder) {
        append_menu_item(&menu, wxID_ANY, _(L("Add color change")) + " (M600)", "",
            [this](wxCommandEvent&) { add_code_as_tick(ColorChangeCode); }, "colorchange_add_m", &menu);

        UseDefaultColors(false);
    }
    else {
        append_change_extruder_menu_item(&menu);
        append_add_color_change_menu_item(&menu);
    }

    append_menu_item(&menu, wxID_ANY, _(L("Add pause print")) + " (M601)", "",
        [this](wxCommandEvent&) { add_code_as_tick(PausePrintCode); }, "pause_print", &menu);

    append_menu_item(&menu, wxID_ANY, _(L("Add custom G-code")), "",
        [this](wxCommandEvent&) { add_code_as_tick(""); }, "edit_gcode", &menu);

    GUI::wxGetApp().plater()->PopupMenu(&menu);
}

void Control::show_edit_context_menu()
{
    wxMenu menu;

    std::set<TickCode>::iterator it = m_ticks.ticks.find(TickCode{ m_selection == ssLower ? m_lower_value : m_higher_value });

    if (it->gcode == ToolChangeCode) {
        if (m_mode == t_mode::MultiAsSingle)
            append_change_extruder_menu_item(&menu);
        append_add_color_change_menu_item(&menu, true);
    }
    else
        append_menu_item(&menu, wxID_ANY, it->gcode == ColorChangeCode ? _(L("Edit color")) :
                                          it->gcode == PausePrintCode  ? _(L("Edit pause print message")) :
                                          _(L("Edit custom G-code")), "",
            [this](wxCommandEvent&) { edit_tick(); }, "edit_uni", &menu);

    if (it->gcode == ColorChangeCode && m_mode == t_mode::MultiAsSingle)
        append_change_extruder_menu_item(&menu, true);

    append_menu_item(&menu, wxID_ANY, it->gcode == ColorChangeCode ? _(L("Delete color change")) : 
                                      it->gcode == ToolChangeCode  ? _(L("Delete tool change")) :
                                      it->gcode == PausePrintCode  ? _(L("Delete pause print")) :
                                      _(L("Delete custom G-code")), "",
        [this](wxCommandEvent&) { delete_current_tick();}, "colorchange_del_f", &menu);

    GUI::wxGetApp().plater()->PopupMenu(&menu);
}

void Control::show_cog_icon_context_menu()
{
    wxMenu menu;

    append_menu_item(&menu, wxID_ANY, _(L("Jump to height")) + " (Shift+G)", "",
        [this](wxCommandEvent&) { jump_to_print_z(); }, "", &menu);

    append_menu_item(&menu, wxID_ANY, _(L("Set extruder sequence for the entire print")), "",
        [this](wxCommandEvent&) { edit_extruder_sequence(); }, "", &menu);

    GUI::wxGetApp().plater()->PopupMenu(&menu);
}

void Control::OnRightUp(wxMouseEvent& event)
{
    if (!HasCapture())
        return;
    this->ReleaseMouse();
    m_is_right_down = m_is_one_layer = false;

    if (m_mouse == maForceColorEdit)
    {
        wxPoint pos = event.GetLogicalPosition(wxClientDC(this));
        int edited_tick = get_edited_tick_for_position(pos);
        if (edited_tick >= 0)
            edit_tick(edited_tick);
    }
    else if (m_mouse == maAddMenu)
        show_add_context_menu();
    else if (m_mouse == maEditMenu)
        show_edit_context_menu();
    else if (m_mouse == maCogIconMenu)
        show_cog_icon_context_menu();

    Refresh();
    Update();
    event.Skip();
}

static std::string get_new_color(const std::string& color)
{
    wxColour clr(color);
    if (!clr.IsOk())
        clr = wxColour(0, 0, 0); // Don't set alfa to transparence

    auto data = new wxColourData();
    data->SetChooseFull(1);
    data->SetColour(clr);

    wxColourDialog dialog(nullptr, data);
    dialog.CenterOnParent();
    if (dialog.ShowModal() == wxID_OK)
        return dialog.GetColourData().GetColour().GetAsString(wxC2S_HTML_SYNTAX).ToStdString();
    return "";
}

/* To avoid get an empty string from wxTextEntryDialog 
 * Let disable OK button, if TextCtrl is empty
 * OR input value is our of range (min..max), when min a nd max are positive
 * */
static void upgrade_text_entry_dialog(wxTextEntryDialog* dlg, double min = -1.0, double max = -1.0)
{
    // detect TextCtrl and OK button
    wxTextCtrl* textctrl {nullptr};
    wxWindowList& dlg_items = dlg->GetChildren();
    for (auto item : dlg_items) {
        textctrl = dynamic_cast<wxTextCtrl*>(item);
        if (textctrl)
            break;
    }

    if (!textctrl)
        return;

    wxButton* btn_OK = static_cast<wxButton*>(dlg->FindWindowById(wxID_OK));
    btn_OK->Bind(wxEVT_UPDATE_UI, [textctrl, min, max](wxUpdateUIEvent& evt)
    {
        bool disable = textctrl->IsEmpty();
        if (!disable && min >= 0.0 && max >= 0.0)
        {
            double value = -1.0;
            if (!textctrl->GetValue().ToCDouble(&value))    // input value couldn't be converted to double
                disable = true;
            else
                disable = value < min || value > max;       // is input value is out of valid range ?
        }

        evt.Enable(!disable);
    }, btn_OK->GetId());
}

static std::string get_custom_code(const std::string& code_in, double height)
{
    wxString msg_text = from_u8(_utf8(L("Enter custom G-code used on current layer"))) + ":";
    wxString msg_header = from_u8((boost::format(_utf8(L("Custom G-code on current layer (%1% mm)."))) % height).str());

    // get custom gcode
    wxTextEntryDialog dlg(nullptr, msg_text, msg_header, code_in,
        wxTextEntryDialogStyle | wxTE_MULTILINE);
    upgrade_text_entry_dialog(&dlg);

    if (dlg.ShowModal() != wxID_OK)
        return "";

    return dlg.GetValue().ToStdString();
}

static std::string get_pause_print_msg(const std::string& msg_in, double height)
{
    wxString msg_text = from_u8(_utf8(L("Enter short message shown on Printer display when a print is paused"))) + ":";
    wxString msg_header = from_u8((boost::format(_utf8(L("Message for pause print on current layer (%1% mm)."))) % height).str());

    // get custom gcode
    wxTextEntryDialog dlg(nullptr, msg_text, msg_header, from_u8(msg_in),
        wxTextEntryDialogStyle);
    upgrade_text_entry_dialog(&dlg);

    if (dlg.ShowModal() != wxID_OK || dlg.GetValue().IsEmpty())
        return "";

    return into_u8(dlg.GetValue());
}

static double get_print_z_to_jump(double active_print_z, double min_z, double max_z)
{
    wxString msg_text = _(L("Enter the height you want to jump to")) + ":";
    wxString msg_header = _(L("Jump to height"));
    wxString msg_in = GUI::double_to_string(active_print_z);

    // get custom gcode
    wxTextEntryDialog dlg(nullptr, msg_text, msg_header, msg_in, wxTextEntryDialogStyle);
    upgrade_text_entry_dialog(&dlg, min_z, max_z);

    if (dlg.ShowModal() != wxID_OK || dlg.GetValue().IsEmpty())
        return -1.0;

    double value = -1.0;
    return dlg.GetValue().ToCDouble(&value) ? value : -1.0;
}

void Control::add_code_as_tick(std::string code, int selected_extruder/* = -1*/)
{
    if (m_selection == ssUndef)
        return;
    const int tick = m_selection == ssLower ? m_lower_value : m_higher_value;

    if ( !check_ticks_changed_event(code) )
        return;

    const int extruder = selected_extruder > 0 ? selected_extruder : std::max<int>(1, m_only_extruder);
    const auto it = m_ticks.ticks.find(TickCode{ tick });
    
    if ( it == m_ticks.ticks.end() ) {
        // try to add tick
        if (!m_ticks.add_tick(tick, code, extruder, m_values[tick]))
            return;
    }
    else if (code == ToolChangeCode || code == ColorChangeCode) {
        // try to switch tick code to ToolChangeCode or ColorChangeCode accordingly
        if (!m_ticks.switch_code_for_tick(it, code, extruder))
            return;
    }
    else
        return;

    post_ticks_changed_event(code);
}

void Control::add_current_tick(bool call_from_keyboard /*= false*/)
{
    if (m_selection == ssUndef)
        return;
    const int tick = m_selection == ssLower ? m_lower_value : m_higher_value;
    auto it = m_ticks.ticks.find(TickCode{ tick });

    if (it != m_ticks.ticks.end() ||    // this tick is already exist
        !check_ticks_changed_event(m_mode == t_mode::MultiAsSingle ? ToolChangeCode : ColorChangeCode))
        return;

    if (m_mode == t_mode::SingleExtruder)
        add_code_as_tick(ColorChangeCode);
    else
    {
        wxMenu menu;

        if (m_mode == t_mode::MultiAsSingle)
            append_change_extruder_menu_item(&menu);
        else
            append_add_color_change_menu_item(&menu);

        wxPoint pos = wxDefaultPosition; 
        /* Menu position will be calculated from mouse click position, but...
         * if function is called from keyboard (pressing "+"), we should to calculate it
         * */
        if (call_from_keyboard)
        {
            int width, height;
            get_size(&width, &height);

            const wxCoord coord = 0.75 * (is_horizontal() ? height : width);
            this->GetPosition(&width, &height);

            pos = is_horizontal() ? 
                  wxPoint(get_position_from_value(tick), height + coord) :
                  wxPoint(width + coord, get_position_from_value(tick));
        }

        GUI::wxGetApp().plater()->PopupMenu(&menu, pos);
    }
}

void Control::delete_current_tick()
{
    if (m_selection == ssUndef)
        return;

    auto it = m_ticks.ticks.find(TickCode{ m_selection == ssLower ? m_lower_value : m_higher_value });
    if (it == m_ticks.ticks.end() ||
        !check_ticks_changed_event(it->gcode))
        return;

    const std::string code = it->gcode;
    m_ticks.ticks.erase(it);
    post_ticks_changed_event(code);
}

void Control::edit_tick(int tick/* = -1*/)
{
    if (tick < 0)
        tick = m_selection == ssLower ? m_lower_value : m_higher_value;
    const std::set<TickCode>::iterator it = m_ticks.ticks.find(TickCode{ tick });

    if (it == m_ticks.ticks.end() ||
        !check_ticks_changed_event(it->gcode))
        return;

    const std::string code = it->gcode;
    if (m_ticks.edit_tick(it, m_values[it->tick]))
        post_ticks_changed_event(code);
}

// switch on/off one layer mode
void Control::switch_one_layer_mode()
{
    m_is_one_layer = !m_is_one_layer;
    if (!m_is_one_layer) {
        SetLowerValue(m_min_value);
        SetHigherValue(m_max_value);
    }
    m_selection == ssLower ? correct_lower_value() : correct_higher_value();
    if (!m_selection) m_selection = ssHigher;
}

// discard all custom changes on DoubleSlider
void Control::discard_all_thicks()
{
    SetLowerValue(m_min_value);
    SetHigherValue(m_max_value);

    m_selection == ssLower ? correct_lower_value() : correct_higher_value();
    if (!m_selection) m_selection = ssHigher;

    m_ticks.ticks.clear();
    post_ticks_changed_event();
    
}

// Set current thumb position to the nearest tick (if it is)
// OR to a value corresponding to the mouse click (pos)
void Control::move_current_thumb_to_pos(wxPoint pos)
{
    const int tick_val = get_tick_near_point(pos);
    const int mouse_val = tick_val >= 0 && m_draw_mode == dmRegular ? tick_val :
        get_value_from_position(pos);
    if (mouse_val >= 0)
    {
        // if (abs(mouse_val - m_lower_value) < abs(mouse_val - m_higher_value)) {
        // if (mouse_val <= m_lower_value) {
        if (m_selection == ssLower) {
            SetLowerValue(mouse_val);
            correct_lower_value();
        //    m_selection = ssLower;
        }
        else {
            SetHigherValue(mouse_val);
            correct_higher_value();
            m_selection = ssHigher;
        }
    }
}

void Control::edit_extruder_sequence()
{
    if (!check_ticks_changed_event(ToolChangeCode))
        return;

    GUI::ExtruderSequenceDialog dlg(m_extruders_sequence);
    if (dlg.ShowModal() != wxID_OK)
        return;
    m_extruders_sequence = dlg.GetValue();

    m_ticks.erase_all_ticks_with_code(ToolChangeCode);

    int tick = 0;
    double value = 0.0;
    int extruder = 0;
    const int extr_cnt = m_extruders_sequence.extruders.size();

    while (tick <= m_max_value)
    {
        const int cur_extruder = m_extruders_sequence.extruders[extruder];

        bool meaningless_tick = tick == 0.0 && cur_extruder == extruder;
        if (!meaningless_tick)
            m_ticks.ticks.emplace(TickCode{tick, ToolChangeCode, cur_extruder + 1, m_extruder_colors[cur_extruder]});

        extruder++;
        if (extruder == extr_cnt)
            extruder = 0;
        if (m_extruders_sequence.is_mm_intervals)
        {
            value += m_extruders_sequence.interval_by_mm;
            auto val_it = std::lower_bound(m_values.begin(), m_values.end(), value - epsilon());

            if (val_it == m_values.end())
                break;

            tick = val_it - m_values.begin();
        }
        else
            tick += m_extruders_sequence.interval_by_layers;
    }

    post_ticks_changed_event(ToolChangeCode);
}

void Control::jump_to_print_z()
{
    double print_z = get_print_z_to_jump(m_values[m_selection == ssLower ? m_lower_value : m_higher_value], 
                                         m_values[m_min_value], m_values[m_max_value]);
    if (print_z < 0)
        return;

    auto it = std::lower_bound(m_values.begin(), m_values.end(), print_z - epsilon());
    int tick_value = it - m_values.begin();

    if (m_selection == ssLower)
        SetLowerValue(tick_value);
    else
        SetHigherValue(tick_value);
}

void Control::post_ticks_changed_event(const std::string& gcode /*= ""*/)
{
    m_force_mode_apply = (gcode.empty() || gcode == ColorChangeCode || gcode == ToolChangeCode);

    wxPostEvent(this->GetParent(), wxCommandEvent(wxCUSTOMEVT_TICKSCHANGED));
}

bool Control::check_ticks_changed_event(const std::string& gcode)
{
    if ( m_ticks.mode == m_mode                                                     ||
        (gcode != ColorChangeCode && gcode != ToolChangeCode)                       ||
        (m_ticks.mode == t_mode::SingleExtruder && m_mode == t_mode::MultiAsSingle) || // All ColorChanges will be applied for 1st extruder
        (m_ticks.mode == t_mode::MultiExtruder  && m_mode == t_mode::MultiAsSingle) )  // Just mark ColorChanges for all unused extruders
        return true;

    if ((m_ticks.mode == t_mode::SingleExtruder && m_mode == t_mode::MultiExtruder ) ||
        (m_ticks.mode == t_mode::MultiExtruder  && m_mode == t_mode::SingleExtruder)    )
    {
        if (!m_ticks.has_tick_with_code(ColorChangeCode))
            return true;

        wxString message = (m_ticks.mode == t_mode::SingleExtruder ?
                            _(L("The last color change data was saved for a single extruder printing.")) :
                            _(L("The last color change data was saved for a multi extruder printing.")) 
                            ) + "\n" +
                            _(L("Your current changes will delete all saved color changes.")) + "\n\n\t" +
                            _(L("Are you sure you want to continue?"));

        wxMessageDialog msg(this, message, _(L("Notice")), wxYES_NO);
        if (msg.ShowModal() == wxID_YES) {
            m_ticks.erase_all_ticks_with_code(ColorChangeCode);
            post_ticks_changed_event(ColorChangeCode);
        }
        return false;
    }
    //          m_ticks_mode == t_mode::MultiAsSingle
    if( m_ticks.has_tick_with_code(ToolChangeCode) )
    {
        wxString message =  m_mode == t_mode::SingleExtruder ?                          (
                            _(L("The last color change data was saved for a multi extruder printing.")) + "\n\n" +
                            _(L("Select YES if you want to delete all saved tool changes, \n"
                                "NO if you want all tool changes switch to color changes, \n"
                                "or CANCEL to leave it unchanged.")) + "\n\n\t" +
                            _(L("Do you want to delete all saved tool changes?"))  
                            ) : ( // t_mode::MultiExtruder
                            _(L("The last color change data was saved for a multi extruder printing with tool changes for whole print.")) + "\n\n" +
                            _(L("Your current changes will delete all saved extruder (tool) changes.")) + "\n\n\t" +
                            _(L("Are you sure you want to continue?"))                  ) ;

        wxMessageDialog msg(this, message, _(L("Notice")), wxYES_NO | (m_mode == t_mode::SingleExtruder ? wxCANCEL : 0));
        const int answer = msg.ShowModal();
        if (answer == wxID_YES) {
            m_ticks.erase_all_ticks_with_code(ToolChangeCode);
            post_ticks_changed_event(ToolChangeCode);
        }
        else if (m_mode == t_mode::SingleExtruder && answer == wxID_NO) {
            m_ticks.switch_code(ToolChangeCode, ColorChangeCode);
            post_ticks_changed_event(ColorChangeCode);
        }
        return false;
    }

    return true;
}

std::string TickCodeInfo::get_color_for_tick(TickCode tick, const std::string& code, const int extruder)
{
    if (mode == t_mode::SingleExtruder && code == ColorChangeCode && m_use_default_colors)
    {
        const std::vector<std::string>& colors = GCodePreviewData::ColorPrintColors();
        if (ticks.empty())
            return colors[0];
        m_default_color_idx++;

        return colors[m_default_color_idx % colors.size()];
    }

    std::string color = (*m_colors)[extruder - 1];

    if (code == ColorChangeCode)
    {
        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->gcode == ColorChangeCode && before_tick_it->extruder == extruder) {
                    color = before_tick_it->color;
                    break;
                }
            }
        }

        color = get_new_color(color);
    }
    return color;
}

bool TickCodeInfo::add_tick(const int tick, std::string& code, const int extruder, double print_z)
{
    std::string color;
    if (code.empty())           // custom Gcode
    {
        code = get_custom_code(custom_gcode, print_z);
        if (code.empty())
            return false;
        custom_gcode = code;
    }
    else if (code == PausePrintCode)
    {
        /* PausePrintCode doesn't need a color, so
         * this field is used for save a short message shown on Printer display
         * */
        color = get_pause_print_msg(pause_print_msg, print_z);
        if (color.empty())
            return false;
        pause_print_msg = color;
    }
    else
    {
        color = get_color_for_tick(TickCode{ tick }, code, extruder);
        if (color.empty())
            return false;
    }

    if (mode == t_mode::SingleExtruder)
        m_use_default_colors = true;

    ticks.emplace(TickCode{ tick, code, extruder, color });
    return true;
}

bool TickCodeInfo::edit_tick(std::set<TickCode>::iterator it, double print_z)
{
    std::string edited_value;
    if (it->gcode == ColorChangeCode)
        edited_value = get_new_color(it->color);
    else if (it->gcode == PausePrintCode)
        edited_value = get_pause_print_msg(it->color, print_z);
    else
        edited_value = get_custom_code(it->gcode, print_z);

    if (edited_value.empty())
        return false;

    TickCode changed_tick = *it;
    if (it->gcode == ColorChangeCode || it->gcode == PausePrintCode) {
        if (it->color == edited_value)
            return false;
        changed_tick.color = edited_value;
    }
    else {
        if (it->gcode == edited_value)
            return false;
        changed_tick.gcode = edited_value;
    }

    ticks.erase(it);
    ticks.emplace(changed_tick);

    return true;
}

void TickCodeInfo::switch_code(const std::string& code_from, const std::string& code_to)
{
    for (auto it{ ticks.begin() }, end{ ticks.end() }; it != end; )
        if (it->gcode == code_from)
        {
            TickCode tick = *it;
            tick.gcode = code_to;
            tick.extruder = 1;
            ticks.erase(it);
            it = ticks.emplace(tick).first;
        }
        else
            ++it;
}

bool TickCodeInfo::switch_code_for_tick(std::set<TickCode>::iterator it, const std::string& code_to, const int extruder)
{
    const std::string color = get_color_for_tick(*it, code_to, extruder);
    if (color.empty())
        return false;

    TickCode changed_tick  = *it;
    changed_tick.gcode      = code_to;
    changed_tick.extruder   = extruder;
    changed_tick.color      = color;

    ticks.erase(it);
    ticks.emplace(changed_tick);

    return true;
}

void TickCodeInfo::erase_all_ticks_with_code(const std::string& gcode)
{
    for (auto it{ ticks.begin() }, end{ ticks.end() }; it != end; ) {
        if (it->gcode == gcode)
            it = ticks.erase(it);
        else
            ++it;
    }
}

bool TickCodeInfo::has_tick_with_code(const std::string& gcode)
{
    for (const TickCode& tick : ticks)
        if (tick.gcode == gcode)
            return true;

    return false;
}

ConflictType TickCodeInfo::is_conflict_tick(const TickCode& tick, t_mode out_mode, int only_extruder, double print_z)
{
    if ((tick.gcode == ColorChangeCode && (
            (mode == t_mode::SingleExtruder && out_mode == t_mode::MultiExtruder ) ||
            (mode == t_mode::MultiExtruder  && out_mode == t_mode::SingleExtruder)    )) ||
        (tick.gcode == ToolChangeCode &&
            (mode == t_mode::MultiAsSingle && out_mode != t_mode::MultiAsSingle)) )
        return ctModeConflict;

    // check ColorChange tick
    if (tick.gcode == ColorChangeCode)
    {
        // We should mark a tick as a "MeaninglessColorChange", 
        // if it has a ColorChange for unused extruder from current print to end of the print
        std::set<int> used_extruders_for_tick = get_used_extruders_for_tick(tick.tick, only_extruder, print_z, out_mode);

        if (used_extruders_for_tick.find(tick.extruder) == used_extruders_for_tick.end())
            return ctMeaninglessColorChange;

        // We should mark a tick as a "Redundant", 
        // if it has a ColorChange for extruder that has not been used before
        if (mode == t_mode::MultiAsSingle && tick.extruder != std::max<int>(only_extruder, 1) )
        {
            auto it = ticks.lower_bound( tick );
            if (it == ticks.begin() && it->gcode == ToolChangeCode && tick.extruder == it->extruder)
                return ctNone;

            while (it != ticks.begin()) {
                --it;
                if (it->gcode == ToolChangeCode && tick.extruder == it->extruder)
                    return ctNone;
            }

            return ctRedundant;
        }
    }

    // check ToolChange tick
    if (mode == t_mode::MultiAsSingle && tick.gcode == ToolChangeCode)
    {
        // We should mark a tick as a "MeaninglessToolChange", 
        // if it has a ToolChange to the same extruder
        auto it = ticks.find(tick);
        if (it == ticks.begin())
            return tick.extruder == std::max<int>(only_extruder, 1) ? ctMeaninglessToolChange : ctNone;

        while (it != ticks.begin()) {
            --it;
            if (it->gcode == ToolChangeCode)
                return tick.extruder == it->extruder ? ctMeaninglessToolChange : ctNone;
        }
    }

    return ctNone;
}

} // DoubleSlider

} // Slic3r