Slic3r::GUI::DesignRowList Class Reference

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

Inheritance diagram for Slic3r::GUI::DesignRowList:

Collaboration diagram for Slic3r::GUI::DesignRowList:

Classes
struct	Action
struct	Row
struct	Hit

Public Member Functions
	DesignRowList (wxWindow *parent, int max_visible, bool selectable=true, long style=wxBORDER_SIMPLE)
void	set_rows (std::vector< Row > rows)
int	selection () const
void	select (int row)
void	unselect ()
void	begin_rename (int row)
void	Rescale ()
bool	AcceptsFocus () const override

Public Attributes
std::function< void()>	on_select
std::function< void()>	on_activate
std::function< void(int row, int id)>	on_action
std::function< void(int row, const wxPoint &screen)>	on_menu
std::function< void(int row, const wxString &name)>	on_rename

Static Public Attributes
static constexpr const char *	hover_chip = "#D4D4D4"

Protected Member Functions
void	OnDrawItem (wxDC &dc, const wxRect &rect, size_t n) const override
void	OnDrawBackground (wxDC &dc, const wxRect &rect, size_t n) const override
wxCoord	OnMeasureItem (size_t n) const override

Private Member Functions
Hit	hit_test (const wxPoint &pt) const
wxRect	cell_rect (const wxRect &row, size_t count, size_t i) const
wxRect	label_rect (const wxRect &row, const Row &r) const
const ScalableBitmap *	icon (const std::string &name) const
void	load_icons ()
void	set_hover (const Hit &h)
void	open_editor (int row)
void	end_rename (bool commit)
void	measure_row ()
void	fit_rows ()

Private Attributes
std::vector< Row >	m_rows
std::map< std::string, ScalableBitmap >	m_icons
int	m_max_visible
bool	m_selectable
int	m_row_h {0}
Hit	m_hover
Hit	m_pressed
wxTextCtrl *	m_editor {nullptr}
int	m_edit_row {wxNOT_FOUND}

Detailed Description

---

Class Documentation

Slic3r::GUI::DesignRowList::Action

struct Slic3r::GUI::DesignRowList::Action

Collaboration diagram for Slic3r::GUI::DesignRowList::Action:

Class Members
string	icon
int	id
wxString	tip

Slic3r::GUI::DesignRowList::Row

struct Slic3r::GUI::DesignRowList::Row

Collaboration diagram for Slic3r::GUI::DesignRowList::Row:

Class Members
vector< Action >	actions
wxColour	colour
wxString	edit_text
string	icon
wxString	label

Constructor & Destructor Documentation

DesignRowList()

Slic3r::GUI::DesignRowList::DesignRowList	(	wxWindow *	parent,
		int	max_visible,
		bool	selectable = true,
		long	style = wxBORDER_SIMPLE )

    : wxVListBox(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, style)
    , m_max_visible(std::max(max_visible, 1))
    , m_selectable(selectable)
{
    // A non-selectable list takes no focus: from the mouse because it consumes the presses that
    // would focus it, below, and from the keyboard through AcceptsFocus(). wxGTK reads that once,
    // while the base class is being built, before the override exists, so it is told here.
    if (!m_selectable)
        SetCanFocus(false);
 
    Bind(wxEVT_LISTBOX, [this](wxCommandEvent&) { if (on_select) on_select(); });
    Bind(wxEVT_LISTBOX_DCLICK, [this](wxCommandEvent&) { if (on_activate) on_activate(); });
 
    Bind(wxEVT_MOTION, [this](wxMouseEvent& e) {
        set_hover(hit_test(e.GetPosition()));
        e.Skip();
    });
    Bind(wxEVT_LEAVE_WINDOW, [this](wxMouseEvent& e) {
        set_hover(Hit{});
        m_pressed = Hit{};
        e.Skip();
    });
    // A press on an action cell is remembered and skipped, so the list still selects the row. A
    // non-selectable list keeps every press from wxVListBox, which would select the row and take
    // the focus.
    Bind(wxEVT_LEFT_DOWN, [this](wxMouseEvent& e) {
        const Hit h = hit_test(e.GetPosition());
        m_pressed = h.cell >= 0 ? h : Hit{};
        if (m_selectable) e.Skip();
    });
    // The second press of a double-click on a cell is a press too, and is not skipped: the list
    // would otherwise turn it into a row double-click, so a quick double toggle of the eye would
    // also open the feature for editing.
    Bind(wxEVT_LEFT_DCLICK, [this](wxMouseEvent& e) {
        const Hit h = hit_test(e.GetPosition());
        if (h.cell < 0) { m_pressed = Hit{}; if (m_selectable) e.Skip(); return; }
        m_pressed = h;
    });
    Bind(wxEVT_LEFT_UP, [this](wxMouseEvent& e) {
        e.Skip();
        const Hit pressed = m_pressed;
        m_pressed = Hit{};
        if (pressed.cell < 0 || hit_test(e.GetPosition()) != pressed)
            return;
        const int id = m_rows[pressed.row].actions[pressed.cell].id;
        // After the click has finished dispatching: the action may rebuild these rows. The row
        // must still exist and still be the selected one, or the click is dropped rather than
        // applied to whatever row took its place. A non-selectable list has no selected row.
        CallAfter([this, row = pressed.row, id] {
            if (row < int(GetItemCount()) && (!m_selectable || row == GetSelection()) && on_action)
                on_action(row, id);
        });
    });
    // Right-click targets the row under the pointer. Skipped, because on MSW a handled right
    // press suppresses the wxEVT_CONTEXT_MENU that follows it.
    Bind(wxEVT_RIGHT_DOWN, [this](wxMouseEvent& e) {
        const Hit h = hit_test(e.GetPosition());
        if (m_selectable && h.row != wxNOT_FOUND) select(h.row);
        e.Skip();
    });
    Bind(wxEVT_CONTEXT_MENU, [this](wxContextMenuEvent& e) {
        wxPoint screen = e.GetPosition();   // screen coordinates; wxDefaultPosition from the keyboard
        int     row    = GetSelection();
        if (screen == wxDefaultPosition) {
            if (row == wxNOT_FOUND) return;
            screen = ClientToScreen(GetItemRect(row).GetBottomLeft());
        } else {
            row = VirtualHitTest(ScreenToClient(screen).y);
        }
        if (row == wxNOT_FOUND || row >= int(m_rows.size()))
            return;
        // On MSW the menu comes with the button's release, and the pointer may have moved to
        // another row since the press selected one: the menu is for the row it opens over.
        if (m_selectable) select(row);
        if (on_menu) on_menu(row, screen);
    });
    // wxVListBox takes every wheel event, even with nothing to scroll, so a short list would stop
    // the sidebar it sits in from scrolling under the pointer. Hand it on instead. Not on GTK,
    // where the sidebar scrolls natively and passes on an unhandled wheel by itself.
    Bind(wxEVT_MOUSEWHEEL, [this](wxMouseEvent& e) {
        end_rename(true);
#ifndef __WXGTK__
        if (GetVisibleRowsBegin() == 0 && GetVisibleRowsEnd() >= GetItemCount()) {
            for (wxWindow* w = GetParent(); w != nullptr; w = w->GetParent())
                if (auto* sw = dynamic_cast<wxScrolledWindow*>(w)) {
                    wxMouseEvent fwd(e);
                    fwd.SetEventObject(sw);
                    sw->GetEventHandler()->ProcessEvent(fwd);
                    return;
                }
        }
#endif
        e.Skip();
    });
    Bind(wxEVT_SIZE, [this](wxSizeEvent& e) {
        end_rename(true);   // the editor sits on a row position the new size may have moved
        e.Skip();
    });
    measure_row();
    fit_rows();
}

References Slic3r::GUI::DesignRowList::Hit::cell, end_rename(), fit_rows(), hit_test(), m_max_visible, m_pressed, m_rows, m_selectable, measure_row(), on_activate, on_menu, on_select, Slic3r::GUI::DesignRowList::Hit::row, select(), Slic3r::GUI::selectable(), set_hover(), style, and Slic3r::GUI::wxMouseEvent.

Here is the call graph for this function:

Member Function Documentation

AcceptsFocus()

bool Slic3r::GUI::DesignRowList::AcceptsFocus ( ) const

inlineoverride

{ return m_selectable && wxVListBox::AcceptsFocus(); }

References m_selectable.

begin_rename()

void Slic3r::GUI::DesignRowList::begin_rename

(

int

row

)

{
    CallAfter([this, row] { open_editor(row); });
}

References open_editor().

Here is the call graph for this function:

cell_rect()

wxRect Slic3r::GUI::DesignRowList::cell_rect ( const wxRect & row, size_t count, size_t i ) const

private

{
    const int side = FromDIP(kCellDip);
    const int x    = row.GetRight() + 1 - FromDIP(kPadDip) - int(count - i) * side;
    return wxRect(x, row.y + (row.height - side) / 2, side, side);
}

References count, Slic3r::GUI::kCellDip, and Slic3r::GUI::kPadDip.

Referenced by hit_test(), label_rect(), and OnDrawItem().

Here is the caller graph for this function:

end_rename()

void Slic3r::GUI::DesignRowList::end_rename ( bool commit )

private

{
    if (m_edit_row == wxNOT_FOUND)
        return;
    // Cleared first: hiding the focused editor moves the focus, whose kill-focus comes back here.
    const int row  = m_edit_row;
    wxString  text = m_editor->GetValue();
    m_edit_row = wxNOT_FOUND;
    m_editor->Hide();
    text.Trim(true).Trim(false);
    if (commit && on_rename && !text.empty())   // a nameless row is worse than a badly named one
        CallAfter([this, row, text] {
            if (on_rename && row < int(GetItemCount()))
                on_rename(row, text);
        });
}

References m_edit_row, m_editor, and on_rename.

Referenced by DesignRowList(), open_editor(), and set_rows().

Here is the caller graph for this function:

fit_rows()

void Slic3r::GUI::DesignRowList::fit_rows ( )

private

{
    const int shown = std::clamp(int(GetItemCount()), 1, m_max_visible);
    // Plus the frame, so the last row is not clipped by it.
    const int h = shown * m_row_h + (GetSize().y - GetClientSize().y);
    SetMinSize(wxSize(-1, h));
    SetMaxSize(wxSize(-1, h));
}

References m_max_visible, and m_row_h.

Referenced by DesignRowList(), Rescale(), and set_rows().

Here is the caller graph for this function:

hit_test()

DesignRowList::Hit Slic3r::GUI::DesignRowList::hit_test ( const wxPoint & pt ) const

private

{
    Hit h;
    h.row = VirtualHitTest(pt.y);
    if (h.row == wxNOT_FOUND || h.row >= int(m_rows.size()))
        return Hit{};
    const wxRect rect = GetItemRect(h.row);
    const auto&  acts = m_rows[h.row].actions;
    for (size_t i = 0; i < acts.size(); ++i)
        if (!acts[i].icon.empty() && cell_rect(rect, acts.size(), i).Contains(pt)) {
            h.cell = int(i);
            break;
        }
    return h;
}

References Slic3r::GUI::DesignRowList::Hit::cell, cell_rect(), icon(), m_rows, and Slic3r::GUI::DesignRowList::Hit::row.

Referenced by DesignRowList().

Here is the call graph for this function:

Here is the caller graph for this function:

icon()

const ScalableBitmap * Slic3r::GUI::DesignRowList::icon ( const std::string & name ) const

private

{
    const auto it = m_icons.find(name);
    return it == m_icons.end() ? nullptr : &it->second;
}

References m_icons.

Referenced by hit_test(), label_rect(), and OnDrawItem().

Here is the caller graph for this function:

label_rect()

wxRect Slic3r::GUI::DesignRowList::label_rect ( const wxRect & row, const Row & r ) const

private

{
    int left = row.x + FromDIP(kPadDip);
    if (const ScalableBitmap* bmp = icon(r.icon))
        left += bmp->GetBmpSize().x + FromDIP(kGapDip);
    const int right = r.actions.empty() ? row.GetRight() + 1 - FromDIP(kPadDip)
                                        : cell_rect(row, r.actions.size(), 0).x - FromDIP(kPadDip);
    return wxRect(left, row.y, std::max(right - left, 0), row.height);
}

References Slic3r::GUI::DesignRowList::Row::actions, cell_rect(), icon(), Slic3r::GUI::DesignRowList::Row::icon, Slic3r::GUI::kGapDip, and Slic3r::GUI::kPadDip.

Referenced by OnDrawItem(), open_editor(), and set_hover().

Here is the call graph for this function:

Here is the caller graph for this function:

load_icons()

void Slic3r::GUI::DesignRowList::load_icons ( )

private

{
    auto load = [this](const std::string& name) {
        if (!name.empty() && m_icons.find(name) == m_icons.end())
            m_icons.emplace(name, ScalableBitmap(this, name, kIconPx));
    };
    for (const Row& r : m_rows) {
        load(r.icon);
        for (const Action& a : r.actions)
            load(a.icon);
    }
}

References Slic3r::GUI::DesignRowList::Action::icon, Slic3r::GUI::kIconPx, load(), m_icons, and m_rows.

Referenced by Rescale(), and set_rows().

Here is the call graph for this function:

Here is the caller graph for this function:

measure_row()

void Slic3r::GUI::DesignRowList::measure_row ( )

private

{
    m_row_h = std::max(GetCharHeight() + 8, FromDIP(kCellDip + 2));
}

References Slic3r::GUI::kCellDip, and m_row_h.

Referenced by DesignRowList(), and Rescale().

Here is the caller graph for this function:

OnDrawBackground()

void Slic3r::GUI::DesignRowList::OnDrawBackground ( wxDC & dc, const wxRect & rect, size_t n ) const

overrideprotected

{
    // ObjectList's selection teal, and the dropdowns' lighter hover teal; both are dark-mapped.
    wxColour bg;
    if (IsSelected(n))
        bg = StateColor::darkModeColorFor(wxColour("#BFE1DE"));
    else if (m_selectable && int(n) == m_hover.row)   // a non-selectable row lights only its icons
        bg = StateColor::darkModeColorFor(wxColour("#E5F0EE"));
    if (!bg.IsOk())
        return;   // the list already cleared to its background colour
    dc.SetPen(*wxTRANSPARENT_PEN);
    dc.SetBrush(wxBrush(bg));
    dc.DrawRectangle(rect);
}

References StateColor::darkModeColorFor(), m_hover, and m_selectable.

Here is the call graph for this function:

OnDrawItem()

void Slic3r::GUI::DesignRowList::OnDrawItem ( wxDC & dc, const wxRect & rect, size_t n ) const

overrideprotected

{
    if (n >= m_rows.size())
        return;
    const Row& r = m_rows[n];
 
    if (const ScalableBitmap* bmp = icon(r.icon)) {
        const wxSize sz = bmp->GetBmpSize();
        dc.DrawBitmap(bmp->bmp(), rect.x + FromDIP(kPadDip), rect.y + (rect.height - sz.y) / 2, true);
    }
 
    const wxRect lr = label_rect(rect, r);
    dc.SetFont(GetFont());
    dc.SetTextForeground(r.colour.IsOk() ? r.colour : GetForegroundColour());
    const wxString text = wxControl::Ellipsize(r.label, dc, wxELLIPSIZE_END, std::max(lr.width, 0));
    dc.DrawText(text, lr.x, lr.y + (lr.height - dc.GetCharHeight()) / 2);
 
    for (size_t i = 0; i < r.actions.size(); ++i) {
        const wxRect cell = cell_rect(rect, r.actions.size(), i);
        if (m_hover.row == int(n) && m_hover.cell == int(i)) {
            // Drawn through a graphics context so the rounded corners are anti-aliased on MSW too,
            // and released before the icon goes on top.
            const wxColour chip = StateColor::darkModeColorFor(wxColour(hover_chip));
            const double   rad  = FromDIP(4);
            std::unique_ptr<wxGraphicsContext> gc(wxGraphicsContext::CreateFromUnknownDC(dc));
            if (gc) {
                gc->SetPen(*wxTRANSPARENT_PEN);
                gc->SetBrush(wxBrush(chip));
                gc->DrawRoundedRectangle(cell.x, cell.y, cell.width, cell.height, rad);
            } else {
                dc.SetPen(*wxTRANSPARENT_PEN);
                dc.SetBrush(wxBrush(chip));
                dc.DrawRoundedRectangle(cell, rad);
            }
        }
        if (const ScalableBitmap* bmp = icon(r.actions[i].icon)) {
            const wxSize sz = bmp->GetBmpSize();
            dc.DrawBitmap(bmp->bmp(), cell.x + (cell.width - sz.x) / 2, cell.y + (cell.height - sz.y) / 2, true);
        }
    }
}

References Slic3r::GUI::DesignRowList::Row::actions, cell_rect(), Slic3r::GUI::DesignRowList::Row::colour, StateColor::darkModeColorFor(), hover_chip, icon(), Slic3r::GUI::DesignRowList::Row::icon, Slic3r::GUI::kPadDip, Slic3r::GUI::DesignRowList::Row::label, label_rect(), m_hover, and m_rows.

Here is the call graph for this function:

OnMeasureItem()

wxCoord Slic3r::GUI::DesignRowList::OnMeasureItem ( size_t n ) const

overrideprotected

{
    return m_row_h;
}

References m_row_h.

open_editor()

void Slic3r::GUI::DesignRowList::open_editor ( int row )

private

{
    if (row < 0 || row >= int(m_rows.size()))
        return;
    end_rename(false);
    if (m_editor == nullptr) {
        // A raw wxTextCtrl, as wxTreeCtrl's own label editor is: it is a transient overlay on one
        // row, not a form field, and ::TextInput's frame would not fit inside the row.
        m_editor = new wxTextCtrl(this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize,
                                  wxTE_PROCESS_ENTER | wxBORDER_SIMPLE);
        m_editor->Hide();
        m_editor->Bind(wxEVT_TEXT_ENTER, [this](wxCommandEvent&) {
            end_rename(true);
            SetFocus();
        });
        // Esc must stop here. CHAR_HOOK reaches the focused editor before its ancestors, and the
        // Design panel's own hook answers Esc whatever holds focus, so a skipped Esc would close
        // the open tool as well as the editor.
        m_editor->Bind(wxEVT_CHAR_HOOK, [this](wxKeyEvent& e) {
            if (e.GetKeyCode() != WXK_ESCAPE) { e.Skip(); return; }
            end_rename(false);
            SetFocus();
        });
        m_editor->Bind(wxEVT_KILL_FOCUS, [this](wxFocusEvent& e) {
            e.Skip();
            end_rename(true);
        });
    }
    if (!IsRowVisible(row))
        ScrollToRow(row);
    const Row&   r  = m_rows[row];
    const wxRect rc = label_rect(GetItemRect(row), r);
    m_editor->SetFont(GetFont());
    m_editor->SetBackgroundColour(GetBackgroundColour());
    m_editor->SetForegroundColour(r.colour.IsOk() ? r.colour : GetForegroundColour());
    m_editor->SetValue(r.edit_text.empty() ? r.label : r.edit_text);
    const int h = std::max(rc.height, m_editor->GetBestSize().y);
    const int y = std::clamp(rc.y + (rc.height - h) / 2, 0, std::max(0, GetClientSize().y - h));
    m_editor->SetSize(rc.x - FromDIP(2), y, rc.width + FromDIP(2), h);
    m_edit_row = row;
    m_editor->Show();
    m_editor->SetFocus();
    m_editor->SelectAll();
}

References Slic3r::GUI::DesignRowList::Row::colour, Slic3r::GUI::DesignRowList::Row::edit_text, end_rename(), Slic3r::GUI::DesignRowList::Row::label, label_rect(), m_edit_row, m_editor, and m_rows.

Referenced by begin_rename().

Here is the call graph for this function:

Here is the caller graph for this function:

Rescale()

void Slic3r::GUI::DesignRowList::Rescale

(

)

{
    m_icons.clear();
    load_icons();
    measure_row();
    // The scrollbar's total is only recomputed when the item count is set; RefreshAll() alone
    // would leave it at the old scale.
    SetItemCount(GetItemCount());
    fit_rows();
    Refresh();
}

References fit_rows(), load_icons(), m_icons, and measure_row().

Here is the call graph for this function:

select()

void Slic3r::GUI::DesignRowList::select

(

int

row

)

{
    if (row < 0 || row >= int(GetItemCount()))
        row = wxNOT_FOUND;
    if (row == GetSelection())
        return;
    SetSelection(row);
    if (on_select) on_select();
}

References on_select.

Referenced by DesignRowList(), and unselect().

Here is the caller graph for this function:

selection()

int Slic3r::GUI::DesignRowList::selection ( ) const

inline

{ return GetSelection(); }

set_hover()

void Slic3r::GUI::DesignRowList::set_hover ( const Hit & h )

private

{
    if (h == m_hover)
        return;
    const int old = m_hover.row;
    m_hover = h;
    if (old != wxNOT_FOUND && old < int(GetItemCount()))
        RefreshRow(old);
    if (h.row != wxNOT_FOUND && h.row != old)
        RefreshRow(h.row);
 
    // The tip names the icon under the pointer, or the whole label where the row cuts it short.
    wxString tip;
    if (h.row != wxNOT_FOUND) {
        const Row& r = m_rows[h.row];
        if (h.cell >= 0)
            tip = r.actions[h.cell].tip;
        else if (GetTextExtent(r.label).x > label_rect(GetItemRect(h.row), r).width)
            tip = r.label;
    }
    if (tip.empty())
        UnsetToolTip();
    else if (tip != GetToolTipText())
        SetToolTip(tip);
}

References Slic3r::GUI::DesignRowList::Row::actions, Slic3r::GUI::DesignRowList::Hit::cell, Slic3r::GUI::DesignRowList::Row::label, label_rect(), m_hover, m_rows, and Slic3r::GUI::DesignRowList::Hit::row.

Referenced by DesignRowList().

Here is the call graph for this function:

Here is the caller graph for this function:

set_rows()

void Slic3r::GUI::DesignRowList::set_rows

(

std::vector< Row >

rows

)

{
    end_rename(false);   // the row it names may no longer be that row
    SetSelection(wxNOT_FOUND);
    m_rows    = std::move(rows);
    m_hover   = Hit{};
    m_pressed = Hit{};
    UnsetToolTip();
    load_icons();
    SetItemCount(m_rows.size());
    fit_rows();
    Refresh();
}

References end_rename(), fit_rows(), load_icons(), m_hover, m_pressed, and m_rows.

Here is the call graph for this function:

unselect()

void Slic3r::GUI::DesignRowList::unselect ( )

inline

{ select(wxNOT_FOUND); }

References select().

Here is the call graph for this function:

Member Data Documentation

hover_chip

const char* Slic3r::GUI::DesignRowList::hover_chip = "#D4D4D4"

staticconstexpr

Referenced by OnDrawItem(), and Slic3r::GUI::style_sidebar_icon_btn().

m_edit_row

int Slic3r::GUI::DesignRowList::m_edit_row {wxNOT_FOUND}

private

{wxNOT_FOUND};

Referenced by end_rename(), and open_editor().

m_editor

wxTextCtrl* Slic3r::GUI::DesignRowList::m_editor {nullptr}

private

{nullptr};   // created on the first rename, then reused

Referenced by end_rename(), and open_editor().

m_hover

Hit Slic3r::GUI::DesignRowList::m_hover

private

Referenced by OnDrawBackground(), OnDrawItem(), set_hover(), and set_rows().

m_icons

std::map<std::string, ScalableBitmap> Slic3r::GUI::DesignRowList::m_icons

private

Referenced by icon(), load_icons(), and Rescale().

m_max_visible

int Slic3r::GUI::DesignRowList::m_max_visible

private

Referenced by DesignRowList(), and fit_rows().

m_pressed

Hit Slic3r::GUI::DesignRowList::m_pressed

private

Referenced by DesignRowList(), and set_rows().

m_row_h

int Slic3r::GUI::DesignRowList::m_row_h {0}

private

{0};          // every row's height, from measure_row()

Referenced by fit_rows(), measure_row(), and OnMeasureItem().

m_rows

std::vector<Row> Slic3r::GUI::DesignRowList::m_rows

private

Referenced by DesignRowList(), hit_test(), load_icons(), OnDrawItem(), open_editor(), set_hover(), and set_rows().

m_selectable

bool Slic3r::GUI::DesignRowList::m_selectable

private

Referenced by DesignRowList(), AcceptsFocus(), and OnDrawBackground().

on_action

std::function<void(int row, int id)> Slic3r::GUI::DesignRowList::on_action

on_activate

std::function<void()> Slic3r::GUI::DesignRowList::on_activate

Referenced by DesignRowList().

on_menu

std::function<void(int row, const wxPoint& screen)> Slic3r::GUI::DesignRowList::on_menu

Referenced by DesignRowList().

on_rename

std::function<void(int row, const wxString& name)> Slic3r::GUI::DesignRowList::on_rename

Referenced by end_rename().

on_select

std::function<void()> Slic3r::GUI::DesignRowList::on_select

Referenced by DesignRowList(), and select().

---

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

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