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

Inheritance diagram for Chart:

Collaboration diagram for Chart:

Classes
class	ButtonToDrag

Public Member Functions
	Chart (wxWindow *parent, wxRect rect, const std::vector< std::pair< float, float > > &initial_buttons, int ramming_speed_size, float sampling, int scale_unit=10)
void	set_xy_range (float x, float y)
float	get_volume () const
float	get_time () const
std::vector< float >	get_ramming_speed (float sampling) const
std::vector< std::pair< float, float > >	get_buttons () const
void	draw ()
void	mouse_clicked (wxMouseEvent &event)
void	mouse_right_button_clicked (wxMouseEvent &event)
void	mouse_moved (wxMouseEvent &event)
void	mouse_double_clicked (wxMouseEvent &event)
void	mouse_left_window (wxMouseEvent &)
void	mouse_released (wxMouseEvent &)
void	paint_event (wxPaintEvent &)

Private Member Functions
wxPoint	math_to_screen (const wxPoint2DDouble &math) const
wxPoint2DDouble	screen_to_math (const wxPoint &screen) const
int	which_button_is_clicked (const wxPoint &point) const
void	recalculate_line ()
void	recalculate_volume ()

Private Attributes
int	side = 10
const int	scale_unit
int	legend_side
wxRect	m_rect
wxPoint	m_previous_mouse
std::vector< ButtonToDrag >	m_buttons
std::vector< int >	m_line_to_draw
wxRect2DDouble	visible_area
ButtonToDrag *	m_dragged = nullptr
float	m_total_volume = 0.f
bool	m_uniform = false

Static Private Attributes
static const bool	fixed_x = true
static const bool	splines = true
static const bool	manual_points_manipulation = false

Detailed Description

Constructor & Destructor Documentation

◆ Chart()

Chart::Chart	(	wxWindow *	parent,
		wxRect	rect,
		const std::vector< std::pair< float, float > > &	initial_buttons,
		int	ramming_speed_size,
		float	sampling,
		int	scale_unit = 10 )

inline

                                                                                                                                                          :
        wxWindow(parent,wxID_ANY,rect.GetTopLeft(),rect.GetSize()),
        scale_unit(scale_unit), legend_side(5*scale_unit)
    {
        SetBackgroundColour(*wxWHITE);
        SetBackgroundStyle(wxBG_STYLE_PAINT);
        m_rect = wxRect(wxPoint(legend_side,0),rect.GetSize()-wxSize(legend_side,legend_side));
        visible_area = wxRect2DDouble(0.0, 0.0, sampling*ramming_speed_size, 60.);
        m_buttons.clear();
        if (initial_buttons.size()>0)
            for (const auto& pair : initial_buttons)
                m_buttons.push_back(wxPoint2DDouble(pair.first,pair.second));
        recalculate_line();
    }

References legend_side, m_buttons, m_rect, recalculate_line(), scale_unit, and visible_area.

Here is the call graph for this function:

Member Function Documentation

◆ draw()

void Chart::draw ( )

                 {
    wxAutoBufferedPaintDC dc(this); // unbuffered DC caused flickering on win
 
    // scaling button and tick line from text size gives better result compared to dc.GetContentScale
    int text_width, text_height;
    dc.GetTextExtent("m",&text_width,&text_height);
    side       = text_width;
    int tick_w = text_width / 2;
 
    dc.SetBrush(GetBackgroundColour());
    dc.SetPen(GetBackgroundColour());
    dc.DrawRectangle(GetClientRect());  // otherwise the background would end up black on windows
 
    dc.SetPen(    wxPen(StateColor::darkModeColorFor(wxColour("#DBDBDB")), 1)); // input box border color
    dc.SetBrush(wxBrush(StateColor::darkModeColorFor(wxColour("#F1F1F1")))); // sidebar titlebar bg color
    dc.DrawRectangle(m_rect);
    
    if (visible_area.m_width < 0.499) {
        dc.SetTextForeground(StateColor::darkModeColorFor(wxColour("#FF6F00"))); // Use orange color for warning
        dc.DrawText(_(L("NO RAMMING AT ALL")),wxPoint(m_rect.GetLeft()+m_rect.GetWidth()/2-legend_side,m_rect.GetBottom()-m_rect.GetHeight()/2));
        return;
    }
    
    
    if (!m_line_to_draw.empty()) {
        for (unsigned int i=0;i<m_line_to_draw.size()-2;++i) {
            int color = 444*((m_rect.GetBottom()-(m_line_to_draw)[i])/double(m_rect.GetHeight()));
            dc.SetPen( wxPen( wxColor(std::min(222,color), 222-std::max(color-222,0), 60), 1) ); // adding blue color sligtly gives a bit more modern look instead using raw red & green
            dc.DrawLine(m_rect.GetLeft()+1+i,(m_line_to_draw)[i],m_rect.GetLeft()+1+i,m_rect.GetBottom());        
        }
        dc.SetPen(wxPen(StateColor::darkModeColorFor(wxColour("#363636")), 1));
        for (unsigned int i=0;i<m_line_to_draw.size()-2;++i) {
            if (splines)
                dc.DrawLine(m_rect.GetLeft()+i,(m_line_to_draw)[i],m_rect.GetLeft()+i+1,(m_line_to_draw)[i+1]);
            else {
                dc.DrawLine(m_rect.GetLeft()+i,(m_line_to_draw)[i],m_rect.GetLeft()+i+1,(m_line_to_draw)[i]);
                dc.DrawLine(m_rect.GetLeft()+i+1,(m_line_to_draw)[i],m_rect.GetLeft()+i+1,(m_line_to_draw)[i+1]);
            }
        }
    }
    
    // draw draggable buttons
    dc.SetBrush(StateColor::darkModeColorFor(wxColour("#009688"))); // orca color for draggable circles
    dc.SetPen(wxPen(StateColor::darkModeColorFor(wxColour("#363636")), 1));
    for (auto& button : m_buttons)
        //dc.DrawRectangle(math_to_screen(button.get_pos())-wxPoint(side/2.,side/2.), wxSize(side,side));
        dc.DrawCircle(math_to_screen(button.get_pos()),side/2.);
        //dc.DrawRectangle(math_to_screen(button.get_pos()-wxPoint2DDouble(0.125,0))-wxPoint(0,5),wxSize(50,10));
 
    dc.SetTextForeground(StateColor::darkModeColorFor(wxColour("#363636"))); // Label color
 
    // draw x-axis:
    float last_mark = -10000;
    for (float math_x=int(visible_area.m_x*10)/10 ; math_x < (visible_area.m_x+visible_area.m_width) ; math_x+=0.1f) {
        int x = math_to_screen(wxPoint2DDouble(math_x,visible_area.m_y)).x;
        int y = m_rect.GetBottom();
        if (x-last_mark < legend_side) continue;
        dc.DrawLine(x,y+tick_w+1,x,y-tick_w); // +1 for border; make sure drawn on both size
        auto label = math_x == 0 ? "0" : wxString().Format(wxT("%.1f") , math_x); // prefer "0" to match text with Y "0"
        dc.GetTextExtent(label,&text_width,&text_height);// center text with lines
        dc.DrawText(label ,wxPoint(x - text_width * .5, y + .8 * scale_unit));
        last_mark = x;
    }
    
    // draw y-axis:
    last_mark=10000;
    for (int math_y=visible_area.m_y ; math_y < (visible_area.m_y+visible_area.m_height) ; math_y+=1) {
        int y = math_to_screen(wxPoint2DDouble(visible_area.m_x,math_y)).y;
        int x = m_rect.GetLeft();
        if (last_mark-y < legend_side) continue;    
        dc.DrawLine(x-tick_w,y,x+tick_w+1,y); // +1 for border; make sure drawn on both size
        auto label = wxString()<<math_y;
        dc.GetTextExtent(label,&text_width,&text_height);// center text with lines & make it right aligned
        dc.DrawText(label ,wxPoint(x - scale_unit - text_width, y - .5 * text_height + 1));
        last_mark = y;
    }
    
    // axis labels:
    wxString label = _(L("Time")) + " (" + _(L("s")) + ")";
    dc.GetTextExtent(label,&text_width,&text_height);
    dc.DrawText(label,wxPoint(0.5*(m_rect.GetRight()+m_rect.GetLeft())-text_width/2.f, m_rect.GetBottom()+0.6*legend_side));
    label = _(L("Volumetric speed")) + " (" + _(L(u8"mm³/s")) + ")";
    dc.GetTextExtent(label,&text_width,&text_height);
    dc.DrawRotatedText(label,wxPoint(0,0.5*(m_rect.GetBottom()+m_rect.GetTop())+text_width/2.f),90);
 
    // draw a label with the value above each button
    for (auto& button : m_buttons) {
        if (!visible_area.Contains(button.get_pos()))
            continue; 
        
        wxPoint button_screen_pos = math_to_screen(button.get_pos());
        wxString value_label = wxString().Format(wxT("%.1f"), button.get_pos().m_y);
 
        int label_width, label_height;
        dc.GetTextExtent(value_label, &label_width, &label_height);
 
        const int padding = 4;
        // Calculate label x position
        int label_x = button_screen_pos.x - (label_width/2); // centered with button
        label_x = std::clamp(label_x, m_rect.GetLeft() + (padding*2), m_rect.GetRight() - label_width - (padding*2)); // adjust to fit within chart bounds
        
        // Calculate label y position
        int label_y = button_screen_pos.y - (side/2) - label_height - (padding*2); // above button
        if (label_y - (padding*2) < m_rect.GetTop()) { // move below the button if there isn't enough space
            label_y = button_screen_pos.y + (side/2) + (padding*2); 
        }
        
        // Draw label background
        dc.SetPen(wxPen(StateColor::darkModeColorFor(wxColour("#DBDBDB")), 1));
        wxColour bg_color = StateColor::darkModeColorFor(wxColour("#F1F1F1"));
        dc.SetBrush(wxBrush(wxColour(bg_color.Red(), bg_color.Green(), bg_color.Blue(), 204))); // 80% opacity
        wxRect label_rect(label_x - padding, label_y - padding, label_width + (2*padding), label_height + (2*padding));
        dc.DrawRoundedRectangle(label_rect, 2);
        
        // Draw the label text
        dc.SetTextForeground(StateColor::darkModeColorFor("#363636")); 
        dc.DrawText(value_label, wxPoint(label_x, label_y));
    }
}

References _, StateColor::darkModeColorFor(), L, legend_side, m_buttons, m_line_to_draw, m_rect, math_to_screen(), scale_unit, side, splines, and visible_area.

Referenced by paint_event().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_buttons()

std::vector< std::pair< float, float > > Chart::get_buttons ( ) const

                                                         {
    std::vector<std::pair<float, float>> buttons_out;
    for (const auto& button : m_buttons)
        buttons_out.push_back(std::make_pair(float(button.get_pos().m_x),float(button.get_pos().m_y)));
    return buttons_out;
}

References m_buttons.

◆ get_ramming_speed()

std::vector< float > Chart::get_ramming_speed ( float sampling ) const

                                                              {
    std::vector<float> speeds_out;
    
    const int number_of_samples = std::round( visible_area.m_width / sampling);
    if (number_of_samples>0) {
        const int dx = (m_line_to_draw.size()-1) / number_of_samples;
        for (int j=0;j<number_of_samples;++j) {
            float left =  screen_to_math(wxPoint(0,m_line_to_draw[j*dx])).m_y;
            float right = screen_to_math(wxPoint(0,m_line_to_draw[(j+1)*dx])).m_y;
            speeds_out.push_back((left+right)/2.f);            
        }
    }
    return speeds_out;
}

References m_line_to_draw, screen_to_math(), and visible_area.

Here is the call graph for this function:

◆ get_time()

float Chart::get_time ( ) const

inline

42{ return visible_area.m_width; }

References visible_area.

◆ get_volume()

float Chart::get_volume ( ) const

inline

41{ return m_total_volume; }

Chart::m_total_volume

float m_total_volume

Definition RammingChart.hpp:121

References m_total_volume.

◆ math_to_screen()

wxPoint Chart::math_to_screen ( const wxPoint2DDouble & math ) const

inlineprivate

                                                              {
        wxPoint screen;
        screen.x = (math.m_x-visible_area.m_x) * (m_rect.GetWidth()  / visible_area.m_width  );
        screen.y = (math.m_y-visible_area.m_y) * (m_rect.GetHeight() / visible_area.m_height );
        screen.y *= -1;
        screen += m_rect.GetLeftBottom();            
        return screen;
    }

References m_rect, and visible_area.

Referenced by draw(), recalculate_line(), and which_button_is_clicked().

Here is the caller graph for this function:

◆ mouse_clicked()

void Chart::mouse_clicked ( wxMouseEvent & event )

                                             {
    m_uniform = (event.GetModifiers() == wxMOD_CONTROL);
    wxPoint point = event.GetPosition();
    int button_index = which_button_is_clicked(point);
    if ( button_index != -1) {
        m_dragged = &m_buttons[button_index];
        m_previous_mouse = point;            
    }
}

References m_buttons, m_dragged, m_previous_mouse, m_uniform, and which_button_is_clicked().

Here is the call graph for this function:

◆ mouse_double_clicked()

void Chart::mouse_double_clicked ( wxMouseEvent & event )

                                                    {
    if (!manual_points_manipulation)
        return;
    wxPoint point = event.GetPosition();
    if (!m_rect.Contains(point))     // the click is outside the chart
        return;
    m_buttons.push_back(screen_to_math(point));
    std::sort(m_buttons.begin(),m_buttons.end());
    recalculate_line();
    return;
}

References m_buttons, m_rect, manual_points_manipulation, recalculate_line(), and screen_to_math().

Here is the call graph for this function:

◆ mouse_left_window()

void Chart::mouse_left_window ( wxMouseEvent & )

inline

53{ m_dragged = nullptr; SetCursor(wxNullCursor);}

References m_dragged.

Referenced by mouse_moved().

Here is the caller graph for this function:

◆ mouse_moved()

void Chart::mouse_moved ( wxMouseEvent & event )

                                           {
    wxPoint pos = event.GetPosition();    
    wxRect rect = m_rect;
    if (!event.Dragging() || !m_dragged){
        // change cursor while button hovered && drag
        SetCursor((which_button_is_clicked(pos) != -1) ? wxCursor(wxCURSOR_SIZENS) : wxNullCursor);
        return;
    }
    rect.Deflate(side/2.);
    if (!(rect.Contains(pos))) {  // the mouse left chart area
        mouse_left_window(event);
        return;
    }    
    int delta_x = pos.x - m_previous_mouse.x;
    int delta_y = pos.y - m_previous_mouse.y;
 
    double new_y = m_dragged->get_pos().m_y - double(delta_y) / m_rect.GetHeight() * visible_area.m_height;
 
    if (m_uniform)
        for (ButtonToDrag& b : m_buttons)
            b.move(fixed_x?0:double(delta_x)/m_rect.GetWidth() * visible_area.m_width, new_y - b.get_pos().m_y); 
    else
        m_dragged->move(fixed_x?0:double(delta_x)/m_rect.GetWidth() * visible_area.m_width, new_y - m_dragged->get_pos().m_y); 
 
    m_previous_mouse = pos;
    recalculate_line();
}

References fixed_x, m_buttons, m_dragged, m_previous_mouse, m_rect, m_uniform, mouse_left_window(), recalculate_line(), side, visible_area, and which_button_is_clicked().

Here is the call graph for this function:

◆ mouse_released()

void Chart::mouse_released ( wxMouseEvent & )

inline

54{ m_dragged = nullptr; SetCursor(wxNullCursor);}

References m_dragged.

◆ mouse_right_button_clicked()

void Chart::mouse_right_button_clicked ( wxMouseEvent & event )

                                                          {
    if (!manual_points_manipulation)
        return;
    wxPoint point = event.GetPosition();
    int button_index = which_button_is_clicked(point);
    if (button_index != -1 && m_buttons.size()>2) {
        m_buttons.erase(m_buttons.begin()+button_index);
        recalculate_line();
    }
}

References m_buttons, manual_points_manipulation, recalculate_line(), and which_button_is_clicked().

Here is the call graph for this function:

◆ paint_event()

void Chart::paint_event ( wxPaintEvent & )

inline

55{ draw(); }

Chart::draw

void draw()

Definition RammingChart.cpp:21

References draw().

Here is the call graph for this function:

◆ recalculate_line()

void Chart::recalculate_line ( )

private

                             {
    m_line_to_draw.clear();
    m_total_volume = 0.f;
 
    std::vector<wxPoint> points;
    for (auto& but : m_buttons) {
        points.push_back(wxPoint(math_to_screen(but.get_pos())));
        if (points.size()>1 && points.back().x==points[points.size()-2].x) points.pop_back();
        if (points.size()>1 && points.back().x > m_rect.GetRight()) {
            points.pop_back();
            break;
        }
    }
 
    // The calculation wouldn't work in case the ramming is to be turned off completely.
    if (points.size()>1) {
        std::sort(points.begin(),points.end(),[](wxPoint& a,wxPoint& b) { return a.x < b.x; });
 
        // Cubic spline interpolation: see https://en.wikiversity.org/wiki/Cubic_Spline_Interpolation#Methods
        const bool boundary_first_derivative = true; // true - first derivative is 0 at the leftmost and rightmost point
                                                     // false - second ---- || -------
        const int N = points.size()-1; // last point can be accessed as N, we have N+1 total points
        std::vector<float> diag(N+1);
        std::vector<float> mu(N+1);
        std::vector<float> lambda(N+1);
        std::vector<float> h(N+1);
        std::vector<float> rhs(N+1);
        
        // let's fill in inner equations
        for (int i=1;i<=N;++i) h[i] = points[i].x-points[i-1].x;
        std::fill(diag.begin(),diag.end(),2.f);
        for (int i=1;i<=N-1;++i) {
            mu[i] = h[i]/(h[i]+h[i+1]);
            lambda[i] = 1.f - mu[i];
            rhs[i] = 6 * ( float(points[i+1].y-points[i].y  )/(h[i+1]*(points[i+1].x-points[i-1].x)) -
                           float(points[i].y  -points[i-1].y)/(h[i]  *(points[i+1].x-points[i-1].x))   );
        }
 
        // now fill in the first and last equations, according to boundary conditions:
        if (boundary_first_derivative) {
            const float endpoints_derivative = 0;
            lambda[0] = 1;
            mu[N]     = 1;
            rhs[0] = (6.f/h[1]) * (float(points[0].y-points[1].y)/(points[0].x-points[1].x) - endpoints_derivative);
            rhs[N] = (6.f/h[N]) * (endpoints_derivative - float(points[N-1].y-points[N].y)/(points[N-1].x-points[N].x));
        }
        else {
            lambda[0] = 0;
            mu[N]     = 0;
            rhs[0]    = 0;
            rhs[N]    = 0;
        }
 
        // the trilinear system is ready to be solved:
        for (int i=1;i<=N;++i) {
            float multiple = mu[i]/diag[i-1];    // let's subtract proper multiple of above equation
            diag[i]-= multiple * lambda[i-1];
            rhs[i] -= multiple * rhs[i-1];
        }
        // now the back substitution (vector mu contains invalid values from now on):
        rhs[N] = rhs[N]/diag[N];
        for (int i=N-1;i>=0;--i)
            rhs[i] = (rhs[i]-lambda[i]*rhs[i+1])/diag[i];
 
        unsigned int i=1;
        float y=0.f;
        for (int x=m_rect.GetLeft(); x<=m_rect.GetRight() ; ++x) {
            if (splines) {
                if (i<points.size()-1 && points[i].x < x ) {
                    ++i;
                }
                if (points[0].x > x)
                    y = points[0].y;
                else
                    if (points[N].x < x)
                        y = points[N].y;
                    else
                        y = (rhs[i-1]*pow(points[i].x-x,3)+rhs[i]*pow(x-points[i-1].x,3)) / (6*h[i]) +
                            (points[i-1].y-rhs[i-1]*h[i]*h[i]/6.f) * (points[i].x-x)/h[i] +
                            (points[i].y  -rhs[i]  *h[i]*h[i]/6.f) * (x-points[i-1].x)/h[i];
                m_line_to_draw.push_back(y);
            }
            else {
                float x_math = screen_to_math(wxPoint(x,0)).m_x;
                if (i+2<=points.size() && m_buttons[i+1].get_pos().m_x-0.125 < x_math)
                    ++i;
                m_line_to_draw.push_back(math_to_screen(wxPoint2DDouble(x_math,m_buttons[i].get_pos().m_y)).y);
            }
 
            m_line_to_draw.back() = std::max(m_line_to_draw.back(), m_rect.GetTop()-1);
            m_line_to_draw.back() = std::min(m_line_to_draw.back(), m_rect.GetBottom()-1);
            m_total_volume += (m_rect.GetBottom() - m_line_to_draw.back()) * (visible_area.m_width / m_rect.GetWidth()) * (visible_area.m_height / m_rect.GetHeight());
        }
    }
 
    wxPostEvent(this->GetParent(), wxCommandEvent(EVT_WIPE_TOWER_CHART_CHANGED));
    Refresh();
}

References m_buttons, m_line_to_draw, m_rect, m_total_volume, math_to_screen(), screen_to_math(), splines, and visible_area.

Referenced by Chart(), mouse_double_clicked(), mouse_moved(), mouse_right_button_clicked(), and set_xy_range().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ recalculate_volume()

void Chart::recalculate_volume ( )

private

◆ screen_to_math()

wxPoint2DDouble Chart::screen_to_math ( const wxPoint & screen ) const

inlineprivate

                                                                {
        wxPoint2DDouble math = screen;
        math -= m_rect.GetLeftBottom();
        math.m_y *= -1;
        math.m_x *= visible_area.m_width   / m_rect.GetWidth();    // scales to [0;1]x[0,1]
        math.m_y *= visible_area.m_height / m_rect.GetHeight();
        return (math+visible_area.GetLeftTop());
    }

References m_rect, and visible_area.

Referenced by get_ramming_speed(), mouse_double_clicked(), and recalculate_line().

Here is the caller graph for this function:

◆ set_xy_range()

void Chart::set_xy_range	(	float	x,
		float	y )

inline

                                       {
        x = int(x/0.25) * 0.25;
        if (x>=0) visible_area.SetRight(x);
        if (y>=0) visible_area.SetBottom(y);
        recalculate_line();
    }

References recalculate_line(), and visible_area.

Here is the call graph for this function:

◆ which_button_is_clicked()

int Chart::which_button_is_clicked ( const wxPoint & point ) const

inlineprivate

                                                            {
        if (!m_rect.Contains(point))
            return -1;
        for (unsigned int i=0;i<m_buttons.size();++i) {
            wxRect rect(math_to_screen(m_buttons[i].get_pos())-wxPoint(side/2.,side/2.),wxSize(side,side)); // bounding rectangle of this button
            if ( rect.Contains(point) )
                return i;
        }
        return (-1);
    }

References m_buttons, m_rect, math_to_screen(), and side.

Referenced by mouse_clicked(), mouse_moved(), and mouse_right_button_clicked().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ fixed_x

const bool Chart::fixed_x = true

staticprivate

Referenced by mouse_moved().

◆ legend_side

int Chart::legend_side

private

Referenced by Chart(), and draw().

◆ m_buttons

std::vector<ButtonToDrag> Chart::m_buttons

private

Referenced by Chart(), draw(), get_buttons(), mouse_clicked(), mouse_double_clicked(), mouse_moved(), mouse_right_button_clicked(), recalculate_line(), and which_button_is_clicked().

◆ m_dragged

ButtonToDrag* Chart::m_dragged = nullptr

private

Referenced by mouse_clicked(), mouse_left_window(), mouse_moved(), and mouse_released().

◆ m_line_to_draw

std::vector<int> Chart::m_line_to_draw

private

Referenced by draw(), get_ramming_speed(), and recalculate_line().

◆ m_previous_mouse

wxPoint Chart::m_previous_mouse

private

Referenced by mouse_clicked(), and mouse_moved().

◆ m_rect

wxRect Chart::m_rect

private

Referenced by Chart(), draw(), math_to_screen(), mouse_double_clicked(), mouse_moved(), recalculate_line(), screen_to_math(), and which_button_is_clicked().

◆ m_total_volume

float Chart::m_total_volume = 0.f

private

Referenced by get_volume(), and recalculate_line().

◆ m_uniform

bool Chart::m_uniform = false

private

Referenced by mouse_clicked(), and mouse_moved().

◆ manual_points_manipulation

const bool Chart::manual_points_manipulation = false

staticprivate

Referenced by mouse_double_clicked(), and mouse_right_button_clicked().

◆ scale_unit

const int Chart::scale_unit

private

Referenced by Chart(), and draw().

◆ side

int Chart::side = 10

private

Referenced by draw(), mouse_moved(), and which_button_is_clicked().

◆ splines

const bool Chart::splines = true

staticprivate

Referenced by draw(), and recalculate_line().

◆ visible_area

wxRect2DDouble Chart::visible_area

private

Referenced by Chart(), draw(), get_ramming_speed(), get_time(), math_to_screen(), mouse_moved(), recalculate_line(), screen_to_math(), and set_xy_range().

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

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

	OrcaSlicer latest OrcaSlicer

Classes

Public Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ Chart()

Member Function Documentation

◆ draw()

◆ get_buttons()

◆ get_ramming_speed()

◆ get_time()

◆ get_volume()

◆ math_to_screen()

◆ mouse_clicked()

◆ mouse_double_clicked()

◆ mouse_left_window()

◆ mouse_moved()

◆ mouse_released()

◆ mouse_right_button_clicked()

◆ paint_event()

◆ recalculate_line()

◆ recalculate_volume()

◆ screen_to_math()

◆ set_xy_range()

◆ which_button_is_clicked()

Member Data Documentation

◆ fixed_x

◆ legend_side

◆ m_buttons

◆ m_dragged

◆ m_line_to_draw

◆ m_previous_mouse

◆ m_rect

◆ m_total_volume

◆ m_uniform

◆ manual_points_manipulation

◆ scale_unit

◆ side

◆ splines

◆ visible_area