Slic3r::GUI::DesignCanvas Class Reference

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

Inheritance diagram for Slic3r::GUI::DesignCanvas:

Collaboration diagram for Slic3r::GUI::DesignCanvas:

Classes
struct	BodyVolume

Public Member Functions
	DesignCanvas (wxWindow *parent)
	~DesignCanvas () override
void	set_bodies (const std::vector< TriangleMesh > *body_meshes, const std::vector< bool > &visible={})
void	clear_mesh ()
void	set_preview_mesh (const TriangleMesh &mesh)
void	clear_preview ()
void	fit_view ()
void	set_view (const std::string &view_name)
bool	zoom_to_box (BoundingBoxf3 box)
BoundingBoxf3	selection_box () const
BoundingBoxf3	faces_box (std::vector< std::pair< int, int > > faces) const
void	begin_sketch (const SketchPlane &plane, DesignSketchTool::Mode mode)
void	edit_sketch (const std::vector< SketchEntity > &entities, const std::vector< SketchEntityConstraintDef > &constraints, const SketchPlane &plane)
void	set_sketch_tool (DesignSketchTool::Mode mode)
void	set_sketch_construction (bool c)
bool	edit_sketch_selection_value ()
int	toggle_sketch_construction_selection ()
bool	sketch_is_selecting () const
bool	add_sketch_regions (const std::vector< std::vector< std::vector< Vec2d > > > &regions)
void	set_sketch_polygon_sides (int n)
void	set_sketch_polygon_circumscribed (bool c)
void	finish_sketch ()
bool	is_sketching () const
void	refresh_bed ()
Vec2d	bed_center () const
void	enter_viewport ()
void	leave_viewport ()
void	unbind_canvas_event_handlers ()
void	reset_canvas_volumes ()
void	set_show_bed (bool b)
void	set_sidebar_collapse (std::function< CollapseSide()> side, std::function< void()> toggle)
void	set_sidebar_collapse_tooltip (const std::string &tooltip)
bool	view_normal_to_sketch ()
void	cancel_sketch ()
void	set_on_sketch_commit (std::function< void(const SketchProfile &, const SketchPlane &)> cb)
void	set_on_sketch_entities_commit (std::function< void(const std::vector< SketchEntity > &, const std::vector< SketchEntityConstraintDef > &, const SketchPlane &)> cb)
void	set_on_segment_drawn (std::function< void(double, double)> cb)
void	set_on_cursor_metrics (std::function< void(double, double, bool)> cb)
void	set_on_solve_state (std::function< void(int, bool, bool)> cb)
void	set_on_sketch_step (std::function< void(DesignSketchTool::Mode, int, int)> cb)
void	apply_segment_length (double len)
void	keep_segment_as_drawn ()
void	set_on_sketch_selection_changed (std::function< void(int)> cb)
void	set_on_sketch_face_selected (std::function< void(int)> cb)
void	set_on_display_sketch_selected (std::function< void(int, int, int)> cb)
void	set_on_display_sketch_activated (std::function< void(int)> cb)
std::vector< SketchEntity >	selected_loop_entities () const
std::vector< std::vector< int > >	region_entity_indices (const std::vector< SketchEntity > &ents) const
std::vector< std::vector< int > >	region_entity_indices_with_holes (const std::vector< SketchEntity > &ents) const
void	clear_loop_pick ()
void	clear_solid_pick ()
void	set_loop_pick (int feature, int region)
int	loop_pick_feature () const
int	loop_pick_region () const
void	set_escalate_on_repick (bool on)
void	set_solid_pick (const std::vector< CadBody > *bodies, const TriangleMesh *mesh, const std::vector< int > *tri_face, const std::vector< int > *tri_body, const std::vector< bool > *visible=nullptr, const std::vector< Transform3d > *xform=nullptr)
void	set_on_solid_selection_changed (std::function< void(int, int, int, int)> cb)
void	set_on_empty_pick (std::function< void()> cb)
std::vector< int >	selected_solid_edges () const
void	select_body (int body)
ColorRGBA	body_color (int body) const
void	begin_move_body (int body, const Vec3d &pivot, const Transform3d &base_xform, double body_radius)
void	clear_move_gizmo ()
void	set_on_body_move_changed (std::function< void(int, const Transform3d &)> cb)
bool	begin_fillet_gizmo (const Vec3d &body_centroid, double radius)
void	clear_fillet_gizmo ()
bool	filleting () const
void	set_on_fillet_radius_changed (std::function< void(double)> cb)
void	begin_hole_gizmo (const SketchPlane &plane, double x, double y, double diameter, double depth, bool through)
void	set_hole_face_bounds (bool has, double umin, double umax, double vmin, double vmax)
void	clear_hole_gizmo ()
bool	holing () const
void	set_on_hole_changed (std::function< void(double, double, double, double)> cb)
void	begin_thread_gizmo (const SketchPlane &plane, double x, double y, double radius, double height)
void	clear_thread_gizmo ()
bool	threading () const
void	set_on_thread_changed (std::function< void(double, double, double, double)> cb)
void	begin_shell_gizmo (const Vec3d &face_centroid, const Vec3d &inward_dir, double thickness)
void	clear_shell_gizmo ()
bool	shelling () const
void	set_on_shell_thickness_changed (std::function< void(double)> cb)
void	begin_revolve_gizmo (const SketchPlane &plane, const Vec2d &centroid, const Vec3d &axis_origin, const Vec3d &axis_dir, double angle, bool flip)
void	clear_revolve_gizmo ()
bool	revolving () const
void	set_on_revolve_angle_changed (std::function< void(double)> cb)
void	set_draft_gizmo (const Vec3d &face_centroid, const Vec3d &face_normal, double angle)
void	clear_draft_gizmo ()
bool	drafting () const
void	set_on_draft_angle_changed (std::function< void(double)> cb)
void	set_cut_gizmo (const SketchPlane &plane, double offset, const Vec3d &body_center, double half_extent)
void	clear_cut_gizmo ()
bool	cutting () const
void	set_on_cut_offset_changed (std::function< void(double)> cb)
void	begin_pattern_gizmo (const SketchPlane &plane, const Vec3d &body_centroid, bool circular, int count, int dir, double spacing, double angle)
void	clear_pattern_gizmo ()
bool	patterning () const
void	set_on_pattern_changed (std::function< void(double)> cb)
void	set_extrude_gizmo (const SketchPlane &plane, const Vec2d &centroid, double depth, double depth2, bool two_sided, bool flip)
void	clear_extrude_gizmo ()
void	set_on_extrude_depth_changed (std::function< void(double, bool)> cb)
void	set_datum_gizmo (const SketchPlane &plane, double usize, double vsize, const Vec3d &base_origin, const Vec3d &base_normal, double offset, bool offset_on)
void	clear_datum_gizmo ()
void	set_on_datum_size_changed (std::function< void(double, double)> cb)
void	set_on_datum_offset_changed (std::function< void(double)> cb)
void	set_helix_gizmo (const SketchPlane &plane, double radius, double pitch, double height, double taper, bool left_handed)
void	clear_helix_gizmo ()
void	set_on_helix_changed (std::function< void(double, double, double)> cb)
void	set_rib_gizmo (const SketchPlane &plane, const Vec2d &p0, const Vec2d &p1, double thickness)
void	clear_rib_gizmo ()
void	set_on_rib_thickness_changed (std::function< void(double)> cb)
void	set_base_pick (std::vector< SketchPlane > planes, std::vector< int > bases, std::vector< std::string > labels={})
void	clear_base_pick ()
void	set_on_datum_base_picked (std::function< void(int)> cb)
void	set_selected_base (std::function< int()> cb)
void	set_on_sketch_exit (std::function< void()> cb)
void	set_on_sketch_exit_refused (std::function< void()> cb)
void	set_on_sketch_notice (std::function< void(const std::string &, bool)> cb)
void	set_display_sketches (std::vector< DesignSketchTool::DisplaySketch > ds)
void	set_highlight_sketches (std::vector< std::pair< int, ColorRGBA > > hl)
void	set_datum_planes (std::vector< SketchPlane > planes, std::vector< Vec2d > sizes={})
void	set_mate_connectors (std::vector< DesignSketchTool::MateConnectorGlyph > g)
void	set_mate_links (std::vector< std::pair< Vec3d, Vec3d > > l)
void	set_highlight_faces (const std::vector< std::pair< int, int > > &faces)
void	set_status_text (const wxString &text, const wxColour &colour)
void	set_operand_bodies (int target_body, int tool_body)
void	set_body_translucent (bool on)
void	set_xray_focus (int body)
void	set_body_hidden (bool on)
void	set_on_context_menu (std::function< void(const wxPoint &)> cb)
bool	delete_selected_sketch_entities ()
bool	inline_busy () const
bool	inline_has_focus () const
void	inline_commit ()
void	inline_cancel ()
void	request_sketch_exit ()
bool	live_sketch_has_work () const
bool	undo_last_sketch_entity ()
bool	redo_last_sketch_entity ()
bool	can_undo_sketch_entity () const
bool	can_redo_sketch_entity () const
void	clear_sketch_selection ()
bool	toggle_planes ()
bool	toggle_axes ()
void	set_section_plane (bool on, double z, bool keep_upper=false)
double	model_mid_z () const
DesignSketchTool::DimType	sketch_dimension_kind () const
double	sketch_dimension_current () const
void	apply_sketch_dimension (double v)
void	open_inline_value (double current, std::function< void(double)> commit, std::function< void()> cancel={})
void	set_on_dimension_pick_complete (std::function< void(double)> cb)
DesignSketchTool::DimType	pending_dimension_type () const
void	set_sketch_dimension_value (double v)
void	cancel_sketch_dimension ()
void	begin_constrain (const SketchProfile &prof, const SketchPlane &plane)
void	end_constrain ()
bool	is_constraining () const
bool	selected_segment (int &a, int &b) const
void	update_constrain_profile (const std::vector< Vec2d > &pts)
void	begin_constrain_entities (const std::vector< SketchEntity > &ents, const SketchPlane &plane)
bool	is_constraining_entities () const
int	sketch_selection_count () const
bool	sketch_abort_gesture ()
bool	sketch_disarm_tool ()
bool	sketch_confirm_pending ()
bool	drawing_in_progress () const
bool	has_any_selection () const
bool	clear_any_selection ()
bool	sketch_first_selected_type (SketchEntity::Type &out) const
const std::vector< int > &	sketch_selection () const
const std::vector< SketchEntity > &	sketch_entities () const
int	sketch_constraint_count () const
const std::vector< SketchEntityConstraintDef > &	sketch_constraints () const
bool	remove_sketch_constraint (int idx)
void	set_on_sketch_constraints_changed (std::function< void()> cb)
bool	try_add_sketch_constraints (const std::vector< SketchEntityConstraintDef > &defs)
void	begin_imported_transform (int feat, const std::vector< std::vector< std::vector< Vec2d > > > &base_regions, const SketchPlane &plane, const Vec2d &offset, double scale_x, double scale_y)
void	set_on_imported_transform (std::function< void(int, Vec2d, double, double)> cb)
bool	selected_constrain_entities (int &e0, int &e1) const
int	selected_constrain_axis () const
bool	pick0_point (Vec2d &out) const
void	update_constrain_entities (const std::vector< SketchEntity > &ents)
void	set_constraint_highlight (std::vector< int > entities)
void	set_constraint_glyphs (std::vector< SketchEntityConstraintDef > cons)
DesignSketchTool &	mcp_sketch_tool ()
const DesignSketchTool &	mcp_sketch_tool () const
void	request_repaint ()
void	force_repaint ()
void	repaint_now ()

Private Member Functions
void	reload ()
void	swap_camera ()
void	rebuild_bodies ()
void	sync_selected_faces ()
void	set_readout (const std::string &text)
void	render_hud ()

Private Attributes
const std::vector< TriangleMesh > *	m_body_meshes {nullptr}
const std::vector< int > *	m_tri_face {nullptr}
std::vector< std::pair< int, int > >	m_lit_faces
std::vector< BodyVolume >	m_volumes
bool	m_split_pending {false}
std::function< void(int, int, int, int)>	m_on_solid_selection_changed
wxGLCanvas *	m_canvas_widget {nullptr}
GLCanvas3D *	m_canvas {nullptr}
int	m_sw_gl {-1}
GLToolbar	m_collapse_toolbar {GLToolbar::Normal, "Collapse"}
std::function< void(const wxPoint &)>	m_on_context_menu
bool	m_ctx_bound {false}
wxPoint	m_ctx_press {0, 0}
bool	m_ctx_travelled {false}
Bed3D	m_bed
Camera	m_parked_camera
bool	m_camera_swapped {false}
Model	m_model
int	m_hl_body_target {-1}
int	m_hl_body_tool {-1}
bool	m_body_translucent {false}
int	m_xray_focus {-1}
bool	m_body_hidden {false}
std::vector< bool >	m_body_visible
const std::vector< CadBody > *	m_color_bodies {nullptr}
DesignSketchTool	m_sketch_tool
bool	m_section_on {false}
std::unique_ptr< SketchInlineEditor >	m_inline_editor
std::string	m_hud_last
wxString	m_status_hud_last
wxColour	m_status_hud_colour
std::function< void(const SketchProfile &, const SketchPlane &)>	m_on_sketch_commit
std::function< void(const std::vector< SketchEntity > &, const std::vector< SketchEntityConstraintDef > &, const SketchPlane &)>	m_on_sketch_entities_commit

Detailed Description

---

Class Documentation

Slic3r::GUI::DesignCanvas::BodyVolume

struct Slic3r::GUI::DesignCanvas::BodyVolume

Class Members
int	body
bool	lit

Constructor & Destructor Documentation

DesignCanvas()

Slic3r::GUI::DesignCanvas::DesignCanvas ( wxWindow * parent )

explicit

    : wxPanel()
{
    if (!Create(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, 0))
        return;
 
    m_canvas_widget = OpenGLManager::create_wxglcanvas(*this);
    if (m_canvas_widget == nullptr)
        return;
 
    m_canvas = new GLCanvas3D(m_canvas_widget, m_bed);
    m_canvas->set_context(wxGetApp().init_glcontext(*m_canvas_widget));
    m_canvas->allow_multisample(OpenGLManager::can_multisample());
    m_canvas->set_config(wxGetApp().plater()->config());
    m_canvas->set_model(&m_model);
    // Nothing to slice here, but GLCanvas3D derefs the process unguarded every frame, so it
    // cannot be null. Borrow the plater's, as the editor canvases do.
    m_canvas->set_process(&wxGetApp().plater()->background_process());
    m_canvas->set_type(GLCanvas3D::ECanvasType::CanvasView3D);
    m_canvas->set_studio_lighting(true);   // see GLCanvas3D::m_studio_lighting and phong.fs
 
    m_canvas->enable_picking(false);   // viewport face/edge picking is custom (TODO)
    m_canvas->enable_moving(false);
    m_canvas->enable_gizmos(false);
    m_canvas->enable_selection(false); // stock volume selection unused; solid highlight is tree-driven
    m_canvas->enable_main_toolbar(false);
    m_canvas->enable_select_plate_toolbar(false);
    m_canvas->enable_assemble_view_toolbar(false);
    m_canvas->enable_separator_toolbar(false);
    m_canvas->enable_collapse_toolbar(false);
    m_canvas->enable_plate_chrome(false);
    m_canvas->enable_labels(false);
    m_canvas->enable_sinking_contours(false); // they would be sliced from the plater's meshes
    m_canvas->set_design_canvas(true);   // home-position bed, triad and CAD grid at the modeling origin
 
    m_canvas->set_design_sketch_tool(&m_sketch_tool);
    m_sketch_tool.on_commit = [this](const SketchProfile& prof, const SketchPlane& pl) {
        if (m_on_sketch_commit) m_on_sketch_commit(prof, pl);
        if (m_canvas) m_canvas->set_as_dirty();
        if (m_canvas_widget) m_canvas_widget->Refresh();
    };
    m_sketch_tool.on_commit_entities = [this](const std::vector<SketchEntity>& ents,
                                              const std::vector<SketchEntityConstraintDef>& cons,
                                              const SketchPlane& pl) {
        if (m_on_sketch_entities_commit) m_on_sketch_entities_commit(ents, cons, pl);
        if (m_canvas) m_canvas->set_as_dirty();
        if (m_canvas_widget) m_canvas_widget->Refresh();
    };
 
    // Onshape-style in-canvas value editor, floating over the GL canvas. The tool hands
    // us a screen pixel (device px) + a commit/cancel pair; we convert to logical client
    // px and wrap the callbacks so each one re-solves and re-renders the viewport.
    m_inline_editor = std::make_unique<SketchInlineEditor>();
    // The tool draws it: it owns the frame's ImGui pass and the render scale. Handing it a raw
    // pointer rather than the unique_ptr keeps the ownership where it was.
    m_sketch_tool.inline_editor = m_inline_editor.get();
    // SCHEDULE a paint, do not render one. request_repaint() renders SYNCHRONOUSLY on software
    // GL, and this callback runs from inside DesignSketchTool::render() — so using it here asks
    // for a render from within a render. The frames stopped after nine, which is what a
    // re-entrancy guard giving up looks like. Refresh() posts a paint event instead: the current
    // frame finishes, the event loop runs (which is where ImGui's queued characters are consumed),
    // and the next frame starts clean.
    // MEASUREMENT: does a typed character reach the GL canvas at all? Everything downstream of
    // this point is known good (ImGui reports want_text=1 and our InputText active), so if these
    // lines do not appear the character never got past the panel's CHAR_HOOK / the focus chain,
    // and no amount of work inside the field will help. Skips always: a pure observer.
    if (m_canvas_widget != nullptr && std::getenv("ORCA_CAD_UXTRACE")) {
        m_canvas_widget->Bind(wxEVT_CHAR, [](wxKeyEvent& e) {
            fprintf(stderr, "[UX] canvas_char key=%d\n", e.GetKeyCode());
            fflush(stderr);
            e.Skip();
        });
    }
    m_inline_editor->request_frame = [this] {
        // BOTH halves, and the dirty flag first: GLCanvas3D's paint handler returns without
        // rendering when the canvas is not marked dirty, so a bare Refresh() posts an event that
        // draws nothing and the frames still stop. request_repaint() does exactly this pair on
        // the hardware path; what it must NOT do here is its software path, which renders
        // synchronously — and this callback runs from inside render().
        if (m_canvas)        m_canvas->set_as_dirty();
        if (m_canvas_widget) m_canvas_widget->Refresh(false);
    };
    m_sketch_tool.on_inline_edit = [this](wxPoint screen_px, double current,
                                          const std::string& title,
                                          std::function<void(double)> commit,
                                          std::function<void()> cancel) {
        if (!m_inline_editor) { if (cancel) cancel(); return; }
        // The tool hands us canvas device px and the field is now drawn IN the canvas, so this
        // is already the coordinate space it wants — no conversion to screen coordinates, and no
        // window to place there.
        // Freeze the sketch tool while the field is open so a stray click/move on the GL
        // canvas can't draw under the field; released on commit or cancel.
        m_sketch_tool.set_inline_busy(true);
        // AND PUT THE KEYBOARD ON THE CANVAS. The field is drawn by ImGui, and ImGui is fed from
        // GLCanvas3D's own key handler, so a key only reaches it if the canvas is the focused
        // widget. That is a focus move WITHIN one window — the toolkit's business, not the window
        // manager's, which is the whole point of not being a window any more — but it still has
        // to be asked for: after a toolbar click or a tree selection the focus is elsewhere in
        // the panel, and the field would sit there taking nothing.
        if (m_canvas_widget) m_canvas_widget->SetFocus();
        m_inline_editor->open(screen_px, current, title,
            [this, commit](double v) {
                m_sketch_tool.set_inline_busy(false);
                if (commit) commit(v);
                // A refused value re-opens the same field (SketchInlineEditor::refuse).
                if (m_inline_editor && m_inline_editor->is_open()) m_sketch_tool.set_inline_busy(true);
                request_repaint();
            },
            [this, cancel]() {
                m_sketch_tool.set_inline_busy(false);
                if (cancel) cancel();
                request_repaint();
            });
    };
    // Let the tool force-close the field (keep-as-drawn) — polyline right-click/double-click
    // ends the chain even while a per-segment value field is open.
    m_sketch_tool.on_inline_dismiss = [this]() {
        if (m_inline_editor) m_inline_editor->cancel();
    };
    m_sketch_tool.on_inline_commit = [this]() {
        if (m_inline_editor) m_inline_editor->commit();
    };
 
    // The two viewport chips — the active tool's values bottom-right, the status line bottom-left
    // — are drawn by the canvas itself, in the tool's ImGui pass: they go away with the canvas,
    // the tab and the window, and never take the keyboard.
    m_sketch_tool.on_readout      = [this](const std::string& s) { set_readout(s); };
    m_sketch_tool.render_overlays = [this] { render_hud(); };
 
    refresh_bed();
 
    // The view this canvas opens on. Built lazily, on the way into the Design tab, so this
    // is the view the user is looking at right now — moved off the current plate onto the
    // Design bed, which stays at the printer bed's home whichever plate is current — turned to
    // the iso view Home returns to, keeping its target and zoom.
    m_parked_camera = wxGetApp().plater()->get_camera();
    if (PartPlate* plate = wxGetApp().plater()->get_partplate_list().get_curr_plate())
        m_parked_camera.translate_world(-plate->get_origin());
    select_iso_view(m_parked_camera);
 
    // Before any of this class's own Binds below: wx calls dynamically bound handlers in
    // reverse order of binding, and GLCanvas3D swallows several events without skipping them —
    // wxEVT_RIGHT_UP and wxEVT_ENTER_WINDOW in on_mouse, and wxEVT_SIZE in on_size, which is
    // just `m_dirty = true;`. For those, whatever is bound LAST is the only handler that runs.
    // The context menu and the focus-follows-mouse depend on running first, which is only true
    // while this call stays ahead of them.
    m_canvas->bind_event_handlers();
 
    // The Design GL canvas only receives key events (Esc to exit/enter Select, Ctrl+Z undo)
    // while it holds keyboard focus. Clicking a side-panel button steals focus, after which
    // Esc/Ctrl+Z silently do nothing until the viewport is clicked again. Restore focus
    // whenever the pointer enters the viewport (focus-follows-mouse, standard CAD behaviour).
    m_canvas_widget->Bind(wxEVT_ENTER_WINDOW, [this](wxMouseEvent& e) {
        // …but NOT while an inline value field is open: the field floats over the canvas, so
        // the smallest pointer jiggle re-enters the viewport and would yank focus off the
        // field (the "no cursor focus on the number, click to focus" bug).
        bool take_focus = m_canvas_widget && !m_sketch_tool.inline_busy();
#if defined(__WXMSW__) && wxUSE_POPUPWIN
        // …nor while a popup is open. A ribbon dropdown opens over the viewport, and the pointer
        // crosses the viewport on its way to it: taking focus then reactivates the frame, which
        // on MSW dismisses the popup under the pointer. GLCanvas3D::on_mouse has the same guard.
        take_focus = take_focus && !wxCurrentPopupWindow;
#endif
        if (take_focus) m_canvas_widget->SetFocus();
        e.Skip();
    });
 
 
    auto* sizer = new wxBoxSizer(wxVERTICAL);
    sizer->Add(m_canvas_widget, 1, wxEXPAND);
    SetSizer(sizer);
    SetMinSize(wxSize(300, 300));
}

References Slic3r::GUI::OpenGLManager::can_multisample(), Slic3r::GUI::GLCanvas3D::CanvasView3D, Slic3r::GUI::OpenGLManager::create_wxglcanvas(), m_bed, m_canvas, m_canvas_widget, m_inline_editor, m_model, m_on_sketch_commit, m_on_sketch_entities_commit, m_parked_camera, m_sketch_tool, Slic3r::GUI::plater(), refresh_bed(), render_hud(), request_repaint(), Slic3r::GUI::select_iso_view(), set_readout(), and Slic3r::GUI::wxMouseEvent.

Here is the call graph for this function:

~DesignCanvas()

Slic3r::GUI::DesignCanvas::~DesignCanvas ( )

override

{
    delete m_canvas;
    delete m_canvas_widget;
}

References m_canvas, and m_canvas_widget.

Member Function Documentation

add_sketch_regions()

bool Slic3r::GUI::DesignCanvas::add_sketch_regions

(

const std::vector< std::vector< std::vector< Vec2d > > > &

regions

)

{
    const bool ok = m_sketch_tool.add_imported_regions(regions);
    if (ok) request_repaint();
    return ok;
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

apply_segment_length()

void Slic3r::GUI::DesignCanvas::apply_segment_length

(

double

len

)

{
    m_sketch_tool.apply_segment_length(len);
    request_repaint();
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

apply_sketch_dimension()

void Slic3r::GUI::DesignCanvas::apply_sketch_dimension

(

double

v

)

{
    m_sketch_tool.apply_dimension(v);
    request_repaint();
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

bed_center()

Vec2d Slic3r::GUI::DesignCanvas::bed_center ( ) const

inline

{ return m_bed.build_volume().bed_center(); }

References m_bed.

begin_constrain()

void Slic3r::GUI::DesignCanvas::begin_constrain	(	const SketchProfile &	prof,
		const SketchPlane &	plane )

{
    m_sketch_tool.begin_constrain(prof, plane);
    // The overlay must appear immediately (no mouse move to trigger a repaint).
    request_repaint();
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

begin_constrain_entities()

void Slic3r::GUI::DesignCanvas::begin_constrain_entities	(	const std::vector< SketchEntity > &	ents,
		const SketchPlane &	plane )

{
    m_sketch_tool.begin_constrain_entities(ents, plane);
    request_repaint();
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

begin_fillet_gizmo()

bool Slic3r::GUI::DesignCanvas::begin_fillet_gizmo	(	const Vec3d &	body_centroid,
		double	radius )

{
    const bool ok = m_sketch_tool.set_fillet_gizmo(body_centroid, radius);
    request_repaint();
    return ok;
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

begin_hole_gizmo()

void Slic3r::GUI::DesignCanvas::begin_hole_gizmo	(	const SketchPlane &	plane,
		double	x,
		double	y,
		double	diameter,
		double	depth,
		bool	through )

{
    m_sketch_tool.set_hole_gizmo(plane, x, y, diameter, depth, through);
    request_repaint();
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

begin_imported_transform()

void Slic3r::GUI::DesignCanvas::begin_imported_transform	(	int	feat,
		const std::vector< std::vector< std::vector< Vec2d > > > &	base_regions,
		const SketchPlane &	plane,
		const Vec2d &	offset,
		double	scale_x,
		double	scale_y )

{
    m_sketch_tool.begin_imported_transform(feat, base_regions, plane, offset, scale_x, scale_y);
    request_repaint();
}

References m_sketch_tool, Slic3r::offset(), and request_repaint().

Here is the call graph for this function:

begin_move_body()

void Slic3r::GUI::DesignCanvas::begin_move_body	(	int	body,
		const Vec3d &	pivot,
		const Transform3d &	base_xform,
		double	body_radius )

{
    m_sketch_tool.set_move_gizmo(body, pivot, base_xform, body_radius);
    request_repaint();
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

begin_pattern_gizmo()

void Slic3r::GUI::DesignCanvas::begin_pattern_gizmo	(	const SketchPlane &	plane,
		const Vec3d &	body_centroid,
		bool	circular,
		int	count,
		int	dir,
		double	spacing,
		double	angle )

{
    m_sketch_tool.set_pattern_gizmo(plane, body_centroid, circular, count, dir, spacing, angle);
    request_repaint();
}

References Slic3r::angle(), count, m_sketch_tool, and request_repaint().

Here is the call graph for this function:

begin_revolve_gizmo()

void Slic3r::GUI::DesignCanvas::begin_revolve_gizmo	(	const SketchPlane &	plane,
		const Vec2d &	centroid,
		const Vec3d &	axis_origin,
		const Vec3d &	axis_dir,
		double	angle,
		bool	flip )

{
    m_sketch_tool.set_revolve_gizmo(plane, centroid, axis_origin, axis_dir, angle, flip);
    request_repaint();
}

References Slic3r::angle(), m_sketch_tool, and request_repaint().

Here is the call graph for this function:

begin_shell_gizmo()

void Slic3r::GUI::DesignCanvas::begin_shell_gizmo	(	const Vec3d &	face_centroid,
		const Vec3d &	inward_dir,
		double	thickness )

{
    m_sketch_tool.set_shell_gizmo(face_centroid, inward_dir, thickness);
    request_repaint();
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

begin_sketch()

void Slic3r::GUI::DesignCanvas::begin_sketch	(	const SketchPlane &	plane,
		DesignSketchTool::Mode	mode )

{
    m_sketch_tool.begin(plane, mode);
    if (m_canvas) m_canvas->set_as_dirty();
    if (m_canvas_widget) m_canvas_widget->Refresh();
}

References m_canvas, m_canvas_widget, and m_sketch_tool.

Referenced by Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_sketch_begin().

Here is the caller graph for this function:

begin_thread_gizmo()

void Slic3r::GUI::DesignCanvas::begin_thread_gizmo	(	const SketchPlane &	plane,
		double	x,
		double	y,
		double	radius,
		double	height )

{
    m_sketch_tool.set_thread_gizmo(plane, x, y, radius, height);
    request_repaint();
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

body_color()

ColorRGBA Slic3r::GUI::DesignCanvas::body_color

(

int

body

)

const

{
    if (m_color_bodies != nullptr && body >= 0 && body < int(m_color_bodies->size())
        && (*m_color_bodies)[body].has_color)
        return (*m_color_bodies)[body].color;
    return body_palette(body);
}

References Slic3r::GUI::body_palette(), and m_color_bodies.

Referenced by reload().

Here is the call graph for this function:

Here is the caller graph for this function:

can_redo_sketch_entity()

bool Slic3r::GUI::DesignCanvas::can_redo_sketch_entity ( ) const

inline

{ return m_sketch_tool.can_redo_entity(); }

References m_sketch_tool.

can_undo_sketch_entity()

bool Slic3r::GUI::DesignCanvas::can_undo_sketch_entity ( ) const

inline

{ return m_sketch_tool.can_undo_entity(); }

References m_sketch_tool.

cancel_sketch()

void Slic3r::GUI::DesignCanvas::cancel_sketch

(

)

{
    m_sketch_tool.cancel();
    if (m_canvas) m_canvas->set_as_dirty();
    if (m_canvas_widget) m_canvas_widget->Refresh();
}

References m_canvas, m_canvas_widget, and m_sketch_tool.

Referenced by Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_sketch_cancel().

Here is the caller graph for this function:

cancel_sketch_dimension()

void Slic3r::GUI::DesignCanvas::cancel_sketch_dimension

(

)

{
    m_sketch_tool.cancel_dimension_value();
    request_repaint();
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

clear_any_selection()

bool Slic3r::GUI::DesignCanvas::clear_any_selection

(

)

{
    if (!has_any_selection()) return false;
    // All three, unconditionally: which is live depends on the mode, and Esc at idle means
    // "nothing is picked" in any of them. clear_selection() reports through the tool's own
    // on_selection_changed; the solid side has no such notification, so the panel refreshes what
    // depends on it (see DesignPanel::escape).
    m_sketch_tool.clear_selection();
    m_sketch_tool.clear_solid_selection();
    m_sketch_tool.clear_display_pick();
    // clear_solid_selection() is silent by design (recomputes call it while ids are invalid), but
    // the panel mirrors the pick to aim Extrude and the dress-up tools. An Esc that cleared the
    // highlight without telling the panel would leave those aimed at a body nothing points to.
    if (m_sketch_tool.on_solid_selection_changed)
        m_sketch_tool.on_solid_selection_changed(0, -1, -1, -1);
    request_repaint();
    return true;
}

References has_any_selection(), m_sketch_tool, and request_repaint().

Here is the call graph for this function:

clear_base_pick()

void Slic3r::GUI::DesignCanvas::clear_base_pick

(

)

{
    m_sketch_tool.clear_base_pick();
    request_repaint();
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

clear_cut_gizmo()

void Slic3r::GUI::DesignCanvas::clear_cut_gizmo

(

)

{
    m_sketch_tool.clear_cut_gizmo();
    request_repaint();
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

clear_datum_gizmo()

void Slic3r::GUI::DesignCanvas::clear_datum_gizmo

(

)

{
    m_sketch_tool.clear_datum_gizmo();
    request_repaint();
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

clear_draft_gizmo()

void Slic3r::GUI::DesignCanvas::clear_draft_gizmo

(

)

{
    m_sketch_tool.clear_draft_gizmo();
    request_repaint();
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

clear_extrude_gizmo()

void Slic3r::GUI::DesignCanvas::clear_extrude_gizmo

(

)

{
    m_sketch_tool.clear_extrude_gizmo();
    request_repaint();
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

clear_fillet_gizmo()

void Slic3r::GUI::DesignCanvas::clear_fillet_gizmo

(

)

{
    m_sketch_tool.clear_fillet_gizmo();
    request_repaint();
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

clear_helix_gizmo()

void Slic3r::GUI::DesignCanvas::clear_helix_gizmo

(

)

{
    m_sketch_tool.clear_helix_gizmo();
    request_repaint();
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

clear_hole_gizmo()

void Slic3r::GUI::DesignCanvas::clear_hole_gizmo

(

)

{
    m_sketch_tool.clear_hole_gizmo();
    request_repaint();
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

clear_loop_pick()

void Slic3r::GUI::DesignCanvas::clear_loop_pick

(

)

{
    m_sketch_tool.clear_display_pick();
}

References m_sketch_tool.

clear_mesh()

void Slic3r::GUI::DesignCanvas::clear_mesh

(

)

{
    m_body_meshes = nullptr;
    m_volumes.clear();
    // No solid, so no edge lines, pick or hover either, as after a rebuild that leaves no body.
    m_sketch_tool.set_solid_pick(nullptr, nullptr, nullptr, nullptr);
    if (!m_model.objects.empty()) {
        m_model.delete_object((size_t)0);
        reload();
    }
}

References m_body_meshes, m_model, m_sketch_tool, m_volumes, and reload().

Referenced by set_bodies().

Here is the call graph for this function:

Here is the caller graph for this function:

clear_move_gizmo()

void Slic3r::GUI::DesignCanvas::clear_move_gizmo

(

)

{
    m_sketch_tool.clear_move_gizmo();
    request_repaint();
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

clear_pattern_gizmo()

void Slic3r::GUI::DesignCanvas::clear_pattern_gizmo

(

)

{
    m_sketch_tool.clear_pattern_gizmo();
    request_repaint();
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

clear_preview()

void Slic3r::GUI::DesignCanvas::clear_preview

(

)

{
    if (m_model.objects.size() > 1) {
        m_model.delete_object((size_t)1);
        reload();
    }
}

References m_model, and reload().

Here is the call graph for this function:

clear_revolve_gizmo()

void Slic3r::GUI::DesignCanvas::clear_revolve_gizmo

(

)

{
    m_sketch_tool.clear_revolve_gizmo();
    request_repaint();
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

clear_rib_gizmo()

void Slic3r::GUI::DesignCanvas::clear_rib_gizmo

(

)

{
    m_sketch_tool.clear_rib_gizmo();
    request_repaint();
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

clear_shell_gizmo()

void Slic3r::GUI::DesignCanvas::clear_shell_gizmo

(

)

{
    m_sketch_tool.clear_shell_gizmo();
    request_repaint();
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

clear_sketch_selection()

void Slic3r::GUI::DesignCanvas::clear_sketch_selection

(

)

{
    m_sketch_tool.clear_selection();
    request_repaint();
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

clear_solid_pick()

void Slic3r::GUI::DesignCanvas::clear_solid_pick

(

)

{
    m_sketch_tool.clear_solid_selection();
    sync_selected_faces();
}

References m_sketch_tool, and sync_selected_faces().

Here is the call graph for this function:

clear_thread_gizmo()

void Slic3r::GUI::DesignCanvas::clear_thread_gizmo

(

)

{
    m_sketch_tool.clear_thread_gizmo();
    request_repaint();
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

cutting()

bool Slic3r::GUI::DesignCanvas::cutting

(

)

const

{ return m_sketch_tool.cutting(); }

References m_sketch_tool.

delete_selected_sketch_entities()

bool Slic3r::GUI::DesignCanvas::delete_selected_sketch_entities

(

)

{
    if (m_sketch_tool.selection().empty()) return false;
    m_sketch_tool.delete_selected();
    request_repaint();
    return true;
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

drafting()

bool Slic3r::GUI::DesignCanvas::drafting

(

)

const

{ return m_sketch_tool.drafting(); }

References m_sketch_tool.

drawing_in_progress()

bool Slic3r::GUI::DesignCanvas::drawing_in_progress

(

)

const

{
    return m_sketch_tool.gesture_pending();
}

References m_sketch_tool.

edit_sketch()

void Slic3r::GUI::DesignCanvas::edit_sketch	(	const std::vector< SketchEntity > &	entities,
		const std::vector< SketchEntityConstraintDef > &	constraints,
		const SketchPlane &	plane )

{
    m_sketch_tool.begin_edit(entities, constraints, plane);
    if (m_canvas) m_canvas->set_as_dirty();
    if (m_canvas_widget) m_canvas_widget->Refresh();
}

References m_canvas, m_canvas_widget, and m_sketch_tool.

edit_sketch_selection_value()

bool Slic3r::GUI::DesignCanvas::edit_sketch_selection_value

(

)

{
    const bool ok = m_sketch_tool.open_selection_dimension_editor();
    if (ok) request_repaint();
    return ok;
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

end_constrain()

void Slic3r::GUI::DesignCanvas::end_constrain

(

)

{
    // cancel() clears m_active + the picked-segment/entity indices, so the
    // constrain overlay (highlighted picks) disappears on the next render.
    m_sketch_tool.cancel();
    request_repaint();
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

enter_viewport()

void Slic3r::GUI::DesignCanvas::enter_viewport

(

)

{
    if (!m_camera_swapped) swap_camera();
    if (m_canvas) { m_canvas->reset_old_size(); m_canvas->set_as_dirty(); }
}

References m_camera_swapped, m_canvas, and swap_camera().

Here is the call graph for this function:

faces_box()

BoundingBoxf3 Slic3r::GUI::DesignCanvas::faces_box ( std::vector< std::pair< int, int > > faces ) const

inline

    {
        return m_sketch_tool.faces_box(std::move(faces));
    }

References m_sketch_tool.

filleting()

bool Slic3r::GUI::DesignCanvas::filleting

(

)

const

{ return m_sketch_tool.filleting(); }

References m_sketch_tool.

finish_sketch()

void Slic3r::GUI::DesignCanvas::finish_sketch

(

)

{
    m_sketch_tool.finish();
    if (m_canvas) m_canvas->set_as_dirty();
    if (m_canvas_widget) m_canvas_widget->Refresh();
}

References m_canvas, m_canvas_widget, and m_sketch_tool.

Referenced by Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_sketch_commit().

Here is the caller graph for this function:

fit_view()

void Slic3r::GUI::DesignCanvas::fit_view

(

)

{
    if (m_canvas && !m_model.objects.empty()) {
        m_canvas->zoom_to_volumes();
        m_canvas->set_as_dirty();
        if (m_canvas_widget)
            m_canvas_widget->Refresh();
    }
}

References m_canvas, m_canvas_widget, and m_model.

force_repaint()

void Slic3r::GUI::DesignCanvas::force_repaint

(

)

{
    if (m_canvas == nullptr || m_canvas_widget == nullptr)
        return;
 
    CallAfter([this]() {
        if (m_canvas == nullptr || m_canvas_widget == nullptr)
            return;
        m_canvas->set_as_dirty();
        m_canvas_widget->Refresh();
        m_canvas_widget->Update();   // synchronous: an expose may never come after a page show
    });
}

References m_canvas, and m_canvas_widget.

has_any_selection()

bool Slic3r::GUI::DesignCanvas::has_any_selection

(

)

const

{
    return m_sketch_tool.has_solid_selection() || m_sketch_tool.sketch_has_selection()
        || m_sketch_tool.display_pick() >= 0;
}

References m_sketch_tool.

Referenced by clear_any_selection().

Here is the caller graph for this function:

holing()

bool Slic3r::GUI::DesignCanvas::holing

(

)

const

{ return m_sketch_tool.holing(); }

References m_sketch_tool.

inline_busy()

bool Slic3r::GUI::DesignCanvas::inline_busy

(

)

const

{
    // Two sources, still: the TOOL's flag says a value is pending, the editor says a field is
    // drawn. They agree now that the field is not a window — the orphan state (logically closed,
    // still on screen, still eating keys) cannot be represented when there is nothing to leave
    // mapped — but the union costs nothing and is the honest question to ask.
    return m_sketch_tool.inline_busy()
           || (m_inline_editor && m_inline_editor->is_open());
}

References m_inline_editor, and m_sketch_tool.

Referenced by set_on_context_menu().

Here is the caller graph for this function:

inline_cancel()

void Slic3r::GUI::DesignCanvas::inline_cancel

(

)

{
    if (m_inline_editor) m_inline_editor->cancel();
}

References m_inline_editor.

inline_commit()

void Slic3r::GUI::DesignCanvas::inline_commit

(

)

{
    if (m_inline_editor) m_inline_editor->commit();
}

References m_inline_editor.

inline_has_focus()

bool Slic3r::GUI::DesignCanvas::inline_has_focus

(

)

const

{
    return m_inline_editor && m_inline_editor->has_focus();
}

References m_inline_editor.

is_constraining()

bool Slic3r::GUI::DesignCanvas::is_constraining

(

)

const

{ return m_sketch_tool.is_constraining(); }

References m_sketch_tool.

is_constraining_entities()

bool Slic3r::GUI::DesignCanvas::is_constraining_entities

(

)

const

{
    return m_sketch_tool.is_constraining_entities();
}

References m_sketch_tool.

is_sketching()

bool Slic3r::GUI::DesignCanvas::is_sketching

(

)

const

{ return m_sketch_tool.is_active(); }

References m_sketch_tool.

Referenced by Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_sketch_begin(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_sketch_cancel(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_sketch_commit(), and Slic3r::GUI::anonymous_namespace{McpControl.cpp}::mcp_sketch().

Here is the caller graph for this function:

keep_segment_as_drawn()

void Slic3r::GUI::DesignCanvas::keep_segment_as_drawn

(

)

{
    m_sketch_tool.keep_segment_as_drawn();
    request_repaint();
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

leave_viewport()

void Slic3r::GUI::DesignCanvas::leave_viewport

(

)

{
    if (m_camera_swapped) swap_camera();
    if (Plater* plater = wxGetApp().plater())
        if (GLCanvas3D* editor = plater->get_current_canvas3D())
            editor->reset_old_size();
}

References m_camera_swapped, Slic3r::GUI::plater(), and swap_camera().

Here is the call graph for this function:

live_sketch_has_work()

bool Slic3r::GUI::DesignCanvas::live_sketch_has_work

(

)

const

{
    return m_sketch_tool.live_sketch_has_work();
}

References m_sketch_tool.

loop_pick_feature()

int Slic3r::GUI::DesignCanvas::loop_pick_feature

(

)

const

{
    return m_sketch_tool.display_pick();
}

References m_sketch_tool.

loop_pick_region()

int Slic3r::GUI::DesignCanvas::loop_pick_region

(

)

const

{
    return m_sketch_tool.display_pick_region();
}

References m_sketch_tool.

mcp_sketch_tool() [1/2]

DesignSketchTool & Slic3r::GUI::DesignCanvas::mcp_sketch_tool ( )

inline

{ return m_sketch_tool; }

References m_sketch_tool.

Referenced by Slic3r::GUI::anonymous_namespace{McpControl.cpp}::mcp_sketch().

Here is the caller graph for this function:

mcp_sketch_tool() [2/2]

const DesignSketchTool & Slic3r::GUI::DesignCanvas::mcp_sketch_tool ( ) const

inline

{ return m_sketch_tool; }

References m_sketch_tool.

model_mid_z()

double Slic3r::GUI::DesignCanvas::model_mid_z

(

)

const

{
    const BoundingBoxf3 bb = m_model.bounding_box_exact();
    return bb.defined ? bb.center().z() : 0.0;
}

References Slic3r::BoundingBox3Base< PointType >::center(), Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::defined, and m_model.

Here is the call graph for this function:

open_inline_value()

void Slic3r::GUI::DesignCanvas::open_inline_value	(	double	current,
		std::function< void(double)>	commit,
		std::function< void()>	cancel = {} )

{
    if (!m_inline_editor || !m_canvas_widget) { if (cancel) cancel(); return; }
    // Host-driven value entry (committed-feature Constrain path): the trigger is a toolbar
    // button. Anchor the field OVER the picked geometry (same as the draw-then-edit tools) when
    // the tool can project it; else fall back to the middle of the canvas, where the sketch is
    // in view. Everything here is canvas DEVICE px, the space the field is drawn in.
    const wxSize  cs = m_canvas_widget->GetClientSize();
    const double  sf = m_canvas_widget->GetContentScaleFactor();
    wxPoint anchor(int(cs.GetWidth() * sf) / 2, int(cs.GetHeight() * sf) / 2);
    m_sketch_tool.constrain_value_anchor(anchor);          // device px in the canvas viewport
    m_sketch_tool.set_inline_busy(true);
    m_canvas_widget->SetFocus();   // same reason as the draw-then-edit path: ImGui reads the
                                   // canvas's key events, so the canvas must be the focused widget
 
    m_inline_editor->open(anchor, current, "",
        [this, commit](double v) {
            m_sketch_tool.set_inline_busy(false);
            if (commit) commit(v);
            if (m_inline_editor && m_inline_editor->is_open()) m_sketch_tool.set_inline_busy(true);
            request_repaint();
        },
        [this, cancel]() {
            m_sketch_tool.set_inline_busy(false);
            if (cancel) cancel();
            request_repaint();
        });
}

References m_canvas_widget, m_inline_editor, m_sketch_tool, and request_repaint().

Here is the call graph for this function:

patterning()

bool Slic3r::GUI::DesignCanvas::patterning

(

)

const

{ return m_sketch_tool.patterning(); }

References m_sketch_tool.

pending_dimension_type()

DesignSketchTool::DimType Slic3r::GUI::DesignCanvas::pending_dimension_type

(

)

const

{
    return m_sketch_tool.pending_dimension_type();
}

References m_sketch_tool.

pick0_point()

bool Slic3r::GUI::DesignCanvas::pick0_point

(

Vec2d &

out

)

const

{
    return m_sketch_tool.pick0_point(out);
}

References m_sketch_tool.

rebuild_bodies()

void Slic3r::GUI::DesignCanvas::rebuild_bodies ( )

private

{
    ModelObject* obj = m_model.objects.empty() ? m_model.add_object() : m_model.objects.front();
    obj->clear_volumes();
    m_volumes.clear();
    const std::vector<TriangleMesh>& meshes = *m_body_meshes;
    size_t ntri = 0;
    for (const TriangleMesh& m : meshes)
        ntri += m.its.indices.size();
    const bool mapped = m_tri_face != nullptr && m_tri_face->size() == ntri;
    size_t off = 0;
    for (int b = 0; b < int(meshes.size()); ++b) {
        const TriangleMesh& mesh = meshes[b];
        const auto first = std::lower_bound(m_lit_faces.begin(), m_lit_faces.end(), std::make_pair(b, INT_MIN));
        const auto last  = std::lower_bound(first, m_lit_faces.end(), std::make_pair(b + 1, INT_MIN));
        if (!mapped || first == last) {
            obj->add_volume(mesh);
            m_volumes.push_back({ b, false });
        } else {
            indexed_triangle_set parts[2];   // [0] the rest of the body, [1] its selected faces
            for (size_t i = 0; i < mesh.its.indices.size(); ++i) {
                const int  f   = (*m_tri_face)[off + i];
                const bool lit = std::binary_search(first, last, std::make_pair(b, f));
                parts[lit].indices.push_back(mesh.its.indices[i]);
            }
            for (int lit = 0; lit < 2; ++lit) {
                if (parts[lit].indices.empty())
                    continue;
                parts[lit].vertices = mesh.its.vertices;
                its_compactify_vertices(parts[lit]);
                obj->add_volume(TriangleMesh(std::move(parts[lit])));
                m_volumes.push_back({ b, lit == 1 });
            }
        }
        off += mesh.its.indices.size();
    }
    if (obj->instances.empty())
        obj->add_instance();
}

References Slic3r::ModelObject::add_instance(), Slic3r::ModelObject::add_volume(), Slic3r::ModelObject::clear_volumes(), Slic3r::f(), Slic3r::ModelObject::instances, Slic3r::TriangleMesh::its, Slic3r::its_compactify_vertices(), m_body_meshes, m_lit_faces, m_model, m_tri_face, and m_volumes.

Referenced by set_bodies(), and sync_selected_faces().

Here is the call graph for this function:

Here is the caller graph for this function:

redo_last_sketch_entity()

bool Slic3r::GUI::DesignCanvas::redo_last_sketch_entity

(

)

{
    const bool did = m_sketch_tool.redo_last_entity();
    if (did) request_repaint();
    return did;
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

refresh_bed()

void Slic3r::GUI::DesignCanvas::refresh_bed

(

)

{
    const DynamicPrintConfig* config = wxGetApp().plater()->config();
    if (!config) return;
    const auto* bed_shape_opt = config->opt<ConfigOptionPoints>("printable_area");
    if (!bed_shape_opt) return;
    double printable_height = 100.0;
    const auto* ph_opt = config->opt<ConfigOptionFloat>("printable_height");
    if (ph_opt) printable_height = ph_opt->value;
    // No position: the Design bed stays at the printer bed's home, whichever plate is current.
    m_bed.set_shape(bed_shape_opt->values, printable_height, {}, {}, "", false);  // mainline added extruder_areas/heights params
}

References m_bed, Slic3r::DynamicConfig::opt(), and Slic3r::printable_height().

Referenced by DesignCanvas().

Here is the call graph for this function:

Here is the caller graph for this function:

region_entity_indices()

std::vector< std::vector< int > > Slic3r::GUI::DesignCanvas::region_entity_indices

(

const std::vector< SketchEntity > &

ents

)

const

{
    return m_sketch_tool.region_entity_indices(ents);
}

References m_sketch_tool.

region_entity_indices_with_holes()

std::vector< std::vector< int > > Slic3r::GUI::DesignCanvas::region_entity_indices_with_holes

(

const std::vector< SketchEntity > &

ents

)

const

{
    return m_sketch_tool.region_entity_indices_with_holes(ents);
}

References m_sketch_tool.

reload()

void Slic3r::GUI::DesignCanvas::reload ( )

private

{
    m_canvas->reset_volumes();
 
    for (int i = 0; i < (int)m_model.objects.size(); ++i)
        m_canvas->load_object(m_model, i);
 
    const ColorRGBA ghost(0.26f, 0.66f, 1.0f, 0.45f);
 
    const auto& volumes = m_canvas->get_volumes().volumes;
    for (auto* v : volumes) {
        int obj_idx = v->object_idx();
        if (obj_idx == 0) {
            // Object 0 holds the bodies (rebuild_bodies): each volume in its body's colour, so
            // coexisting solids read as distinct parts (Onshape per-part colour), or in the
            // selection colour when it holds the body's selected faces.
            const int  vi  = v->volume_idx();
            const int  b   = vi < int(m_volumes.size()) ? m_volumes[vi].body : vi;
            const bool lit = vi < int(m_volumes.size()) && m_volumes[vi].lit;
            bool hidden = (b >= 0 && b < int(m_body_visible.size())) && !m_body_visible[b];
            // Preview-only mode (fillet/chamfer/draft, once a valid target is picked): hide
            // every base body so only the result ghost is on screen until Confirm.
            if (m_body_hidden) hidden = true;
            v->is_active = !hidden;   // per-body visibility toggle
            if (!hidden) {
                ColorRGBA c = lit ? design_selection_color() : body_color(b);
                if (b == m_hl_body_target)    c = ColorRGBA(0.30f, 0.90f, 0.70f, 1.0f); // target = teal-green
                else if (b == m_hl_body_tool) c = ColorRGBA(1.00f, 0.55f, 0.15f, 1.0f); // tool = orange
                if (m_body_translucent) c.a(0.30f);
                else if (m_xray_focus >= 0 && b != m_xray_focus) c.a(0.25f);
                v->set_color(c);
            }
        } else if (obj_idx == 1) {
            // The ghost is the whole resulting model, normally drawn as a faint blue overlay on
            // the visible bodies. Every face the feature leaves alone is in both, at the same
            // depth, so the ghost is drawn with a depth bias: the bodies win on those faces instead
            // of the two copies z-fighting, and the ghost shows only where the result reaches past
            // the bodies. In preview-only mode it IS the result (base bodies hidden), so render it
            // opaque so it reads as a finished solid rather than a see-through hint.
            v->set_color(m_body_hidden ? ColorRGBA(0.40f, 0.82f, 1.0f, 1.0f) : ghost);
            v->depth_bias = true;
        }
    }
 
    // The camera stays where the user left it, even for the first body: Home and a double-click
    // fit on demand.
    m_canvas->set_as_dirty();
    if (m_canvas_widget)
        m_canvas_widget->Refresh();
}

References Slic3r::ColorRGBA::a(), body_color(), Slic3r::GUI::design_selection_color(), m_body_hidden, m_body_translucent, m_body_visible, m_canvas, m_canvas_widget, m_hl_body_target, m_hl_body_tool, m_model, m_volumes, and m_xray_focus.

Referenced by clear_mesh(), clear_preview(), set_bodies(), set_body_hidden(), set_body_translucent(), set_operand_bodies(), set_preview_mesh(), set_xray_focus(), and sync_selected_faces().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_sketch_constraint()

bool Slic3r::GUI::DesignCanvas::remove_sketch_constraint

(

int

idx

)

{
    const bool removed = m_sketch_tool.remove_constraint(idx);
    if (removed) request_repaint();
    return removed;
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

render_hud()

void Slic3r::GUI::DesignCanvas::render_hud ( )

private

{
    if (m_hud_last.empty() && m_status_hud_last.IsEmpty()) return;
    ImGuiWrapper& imgui  = *wxGetApp().imgui();
    const ImVec2  ds     = ImGui::GetIO().DisplaySize;
    const float   em     = imgui.get_style_scaling();   // follows the font, so the DPI
    const float   margin = 12.f * em;
    const int     flags  = ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_AlwaysAutoResize |
                           ImGuiWindowFlags_NoInputs | ImGuiWindowFlags_NoSavedSettings |
                           ImGuiWindowFlags_NoFocusOnAppearing | ImGuiWindowFlags_NoNav;
    auto chip = [&](const char* id, const std::string& text, float x, float pivot_x, float wrap,
                    const ImVec4* colour) {
        ImGuiWrapper::push_common_window_style(m_canvas->get_scale());
        ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(8.f * em, 4.f * em));
        imgui.set_next_window_pos(x, ds.y - margin, ImGuiCond_Always, pivot_x, 1.f);
        imgui.begin(std::string(id), flags);
        if (wrap > 0.f) ImGui::PushTextWrapPos(wrap);
        if (colour) ImGui::PushStyleColor(ImGuiCol_Text, *colour);
        ImGui::TextUnformatted(text.c_str());
        if (colour) ImGui::PopStyleColor();
        if (wrap > 0.f) ImGui::PopTextWrapPos();
        imgui.end();
        ImGui::PopStyleVar();
        ImGuiWrapper::pop_common_window_style();
    };
    if (!m_status_hud_last.IsEmpty()) {
        // Past the view cube and the round view buttons, which own the bottom-left corner. Asked
        // of the canvas, which lays them out: they follow the monitor's DPI on Windows, where `em`
        // does not, so a fixed inset in `em` let them cover the start of the line at 150%.
        // A sentence can be a sentence: it wraps to the room left of the readout chip.
        const float  left = m_canvas->get_canvas_toolbar_right() + margin;
        const ImVec4 col  = m_status_hud_colour.IsOk()
            ? ImVec4(m_status_hud_colour.Red() / 255.f, m_status_hud_colour.Green() / 255.f,
                     m_status_hud_colour.Blue() / 255.f, 1.f)
            : ImVec4();
        chip("##design_status", m_status_hud_last.ToUTF8().data(), left, 0.f,
             std::max(ds.x * 0.6f - left, 120.f * em), m_status_hud_colour.IsOk() ? &col : nullptr);
    }
    if (!m_hud_last.empty())
        chip("##design_readout", m_hud_last, ds.x - margin, 1.f, 0.f, &ImGuiWrapper::COL_ORCA);
}

References Slic3r::GUI::ImGuiWrapper::begin(), Slic3r::GUI::ImGuiWrapper::COL_ORCA, Slic3r::GUI::ImGuiWrapper::end(), Slic3r::GUI::ImGuiWrapper::get_style_scaling(), m_canvas, m_hud_last, m_status_hud_colour, m_status_hud_last, Slic3r::GUI::ImGuiWrapper::pop_common_window_style(), Slic3r::GUI::ImGuiWrapper::push_common_window_style(), and Slic3r::GUI::ImGuiWrapper::set_next_window_pos().

Referenced by DesignCanvas().

Here is the call graph for this function:

Here is the caller graph for this function:

repaint_now()

void Slic3r::GUI::DesignCanvas::repaint_now

(

)

{
    if (m_canvas == nullptr || m_canvas_widget == nullptr)
        return;
    request_repaint();            // mark dirty + Refresh (hardware GL) or render (software GL)
    m_canvas_widget->Update();    // service the pending paint immediately (a modal popup owns the loop)
}

References m_canvas, m_canvas_widget, and request_repaint().

Here is the call graph for this function:

request_repaint()

void Slic3r::GUI::DesignCanvas::request_repaint

(

)

{
    if (!m_canvas)
        return;
    m_canvas->set_as_dirty();
 
    // NOTHING may touch GL before the canvas has initialised it. The backend probe below calls
    // OpenGLManager::get_gl_info().get_renderer(), which runs GLInfo::detect() -> glGetString
    // with no context current and, before init_opengl(), no loaded function pointers — a
    // segfault at startup with no window and nothing in the log. Anything that asks for a
    // repaint while the panel is still being built lands here, so the guard belongs at the top
    // rather than around the render() call: the crash was in the PROBE, not in the paint.
    if (!m_canvas->is_initialized()) {
        if (m_canvas_widget)
            m_canvas_widget->Refresh();   // the first real paint draws the current state anyway
        return;
    }
 
    if (m_sw_gl < 0) {
        // Cache the backend once it's known; the renderer string is empty until
        // GL is initialised, so stay "unknown" and take the safe direct path till then.
        const std::string& r = OpenGLManager::get_gl_info().get_renderer();
        if (!r.empty())
            m_sw_gl = (boost::icontains(r, "llvmpipe") || boost::icontains(r, "softpipe") ||
                       boost::icontains(r, "swrast")   || boost::icontains(r, "software")) ? 1 : 0;
    }
 
    if (m_sw_gl == 0) {
        if (m_canvas_widget)
            m_canvas_widget->Refresh();   // hardware GL: paint cycle drives render()
    } else {
        m_canvas->render();               // software GL or backend not yet known
    }
}

References Slic3r::GUI::OpenGLManager::get_gl_info(), Slic3r::GUI::OpenGLManager::GLInfo::get_renderer(), m_canvas, m_canvas_widget, and m_sw_gl.

Referenced by DesignCanvas(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_sketch_add(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_sketch_construction(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_sketch_delete(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_sketch_heal(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_sketch_mirror(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_sketch_offset(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_sketch_select(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_sketch_set_value(), add_sketch_regions(), apply_segment_length(), apply_sketch_dimension(), begin_constrain(), begin_constrain_entities(), begin_fillet_gizmo(), begin_hole_gizmo(), begin_imported_transform(), begin_move_body(), begin_pattern_gizmo(), begin_revolve_gizmo(), begin_shell_gizmo(), begin_thread_gizmo(), cancel_sketch_dimension(), clear_any_selection(), clear_base_pick(), clear_cut_gizmo(), clear_datum_gizmo(), clear_draft_gizmo(), clear_extrude_gizmo(), clear_fillet_gizmo(), clear_helix_gizmo(), clear_hole_gizmo(), clear_move_gizmo(), clear_pattern_gizmo(), clear_revolve_gizmo(), clear_rib_gizmo(), clear_shell_gizmo(), clear_sketch_selection(), clear_thread_gizmo(), delete_selected_sketch_entities(), edit_sketch_selection_value(), end_constrain(), keep_segment_as_drawn(), open_inline_value(), redo_last_sketch_entity(), remove_sketch_constraint(), repaint_now(), request_sketch_exit(), select_body(), set_base_pick(), set_constraint_glyphs(), set_constraint_highlight(), set_cut_gizmo(), set_datum_gizmo(), set_datum_planes(), set_display_sketches(), set_draft_gizmo(), set_extrude_gizmo(), set_helix_gizmo(), set_highlight_faces(), set_highlight_sketches(), set_loop_pick(), set_mate_connectors(), set_mate_links(), set_on_context_menu(), set_rib_gizmo(), set_section_plane(), set_show_bed(), set_sketch_dimension_value(), set_status_text(), sketch_abort_gesture(), sketch_confirm_pending(), sketch_disarm_tool(), toggle_axes(), toggle_planes(), toggle_sketch_construction_selection(), undo_last_sketch_entity(), update_constrain_entities(), update_constrain_profile(), view_normal_to_sketch(), and zoom_to_box().

Here is the call graph for this function:

request_sketch_exit()

void Slic3r::GUI::DesignCanvas::request_sketch_exit

(

)

{
    m_sketch_tool.request_exit();
    request_repaint();
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

reset_canvas_volumes()

void Slic3r::GUI::DesignCanvas::reset_canvas_volumes

(

)

{
    if (m_canvas) m_canvas->reset_volumes();
}

References m_canvas.

revolving()

bool Slic3r::GUI::DesignCanvas::revolving

(

)

const

{ return m_sketch_tool.revolving(); }

References m_sketch_tool.

select_body()

void Slic3r::GUI::DesignCanvas::select_body

(

int

body

)

{
    m_sketch_tool.select_body(body);
    sync_selected_faces();
    request_repaint();
}

References m_sketch_tool, request_repaint(), and sync_selected_faces().

Here is the call graph for this function:

selected_constrain_axis()

int Slic3r::GUI::DesignCanvas::selected_constrain_axis

(

)

const

{
    return m_sketch_tool.pick2();
}

References m_sketch_tool.

selected_constrain_entities()

bool Slic3r::GUI::DesignCanvas::selected_constrain_entities	(	int &	e0,
		int &	e1 ) const

{
    return m_sketch_tool.selected_constrain_entities(e0, e1);
}

References m_sketch_tool.

selected_loop_entities()

std::vector< SketchEntity > Slic3r::GUI::DesignCanvas::selected_loop_entities

(

)

const

{
    return m_sketch_tool.selected_loop_entities();
}

References m_sketch_tool.

selected_segment()

bool Slic3r::GUI::DesignCanvas::selected_segment	(	int &	a,
		int &	b ) const

{
    return m_sketch_tool.selected_segment(a, b);
}

References m_sketch_tool.

selected_solid_edges()

std::vector< int > Slic3r::GUI::DesignCanvas::selected_solid_edges

(

)

const

{
    return m_sketch_tool.selected_edges();
}

References m_sketch_tool.

selection_box()

BoundingBoxf3 Slic3r::GUI::DesignCanvas::selection_box ( ) const

inline

{ return m_sketch_tool.selection_box(); }

References m_sketch_tool.

set_base_pick()

void Slic3r::GUI::DesignCanvas::set_base_pick	(	std::vector< SketchPlane >	planes,
		std::vector< int >	bases,
		std::vector< std::string >	labels = {} )

{
    m_sketch_tool.set_base_pick(std::move(planes), std::move(bases), std::move(labels));
    request_repaint();
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

set_bodies()

void Slic3r::GUI::DesignCanvas::set_bodies	(	const std::vector< TriangleMesh > *	body_meshes,
		const std::vector< bool > &	visible = {} )

{
    // Object 0 is built by rebuild_bodies; picking uses the combined mesh from set_solid_pick.
    m_body_visible = visible;   // empty => all visible; reload() reads this per volume
    if (body_meshes == nullptr || body_meshes->empty()) { clear_mesh(); return; }
 
    m_body_meshes = body_meshes;
    m_sketch_tool.refresh_body_edges();   // of the bodies set_solid_pick() pointed the tool at
    m_lit_faces   = m_sketch_tool.selected_faces();
    rebuild_bodies();
    reload();
}

References clear_mesh(), m_body_meshes, m_body_visible, m_lit_faces, m_sketch_tool, rebuild_bodies(), and reload().

Here is the call graph for this function:

set_body_hidden()

void Slic3r::GUI::DesignCanvas::set_body_hidden

(

bool

on

)

{
    if (m_body_hidden == on) return;
    m_body_hidden = on;
    m_sketch_tool.set_body_edges_hidden(on);
    reload();   // hides/show base bodies + flips the ghost opaque/faint for preview-only mode
}

References m_body_hidden, m_sketch_tool, and reload().

Referenced by set_section_plane().

Here is the call graph for this function:

Here is the caller graph for this function:

set_body_translucent()

void Slic3r::GUI::DesignCanvas::set_body_translucent

(

bool

on

)

{
    if (m_body_translucent == on) return;
    m_body_translucent = on;
    reload();   // re-applies object-0 alpha so the solid fades for the fillet preview
}

References m_body_translucent, and reload().

Referenced by set_section_plane().

Here is the call graph for this function:

Here is the caller graph for this function:

set_constraint_glyphs()

void Slic3r::GUI::DesignCanvas::set_constraint_glyphs

(

std::vector< SketchEntityConstraintDef >

cons

)

{
    m_sketch_tool.set_constraint_glyphs(std::move(cons));
    request_repaint();
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

set_constraint_highlight()

void Slic3r::GUI::DesignCanvas::set_constraint_highlight

(

std::vector< int >

entities

)

{
    m_sketch_tool.set_constraint_highlight(std::move(entities));
    request_repaint();
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

set_cut_gizmo()

void Slic3r::GUI::DesignCanvas::set_cut_gizmo	(	const SketchPlane &	plane,
		double	offset,
		const Vec3d &	body_center,
		double	half_extent )

{
    m_sketch_tool.set_cut_gizmo(plane, offset, body_center, half_extent);
    request_repaint();
}

References m_sketch_tool, Slic3r::offset(), and request_repaint().

Here is the call graph for this function:

set_datum_gizmo()

void Slic3r::GUI::DesignCanvas::set_datum_gizmo	(	const SketchPlane &	plane,
		double	usize,
		double	vsize,
		const Vec3d &	base_origin,
		const Vec3d &	base_normal,
		double	offset,
		bool	offset_on )

{
    m_sketch_tool.set_datum_gizmo(plane, usize, vsize, base_origin, base_normal, offset, offset_on);
    request_repaint();
}

References m_sketch_tool, Slic3r::offset(), and request_repaint().

Here is the call graph for this function:

set_datum_planes()

void Slic3r::GUI::DesignCanvas::set_datum_planes	(	std::vector< SketchPlane >	planes,
		std::vector< Vec2d >	sizes = {} )

{
    m_sketch_tool.set_datum_planes(std::move(planes), std::move(sizes));
    request_repaint();
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

set_display_sketches()

void Slic3r::GUI::DesignCanvas::set_display_sketches

(

std::vector< DesignSketchTool::DisplaySketch >

ds

)

{
    m_sketch_tool.set_display_sketches(std::move(ds));
    // Overlay changed programmatically (no mouse event) — force a repaint.
    request_repaint();
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

set_draft_gizmo()

void Slic3r::GUI::DesignCanvas::set_draft_gizmo	(	const Vec3d &	face_centroid,
		const Vec3d &	face_normal,
		double	angle )

{
    m_sketch_tool.set_draft_gizmo(face_centroid, face_normal, angle);
    request_repaint();
}

References Slic3r::angle(), Slic3r::face_normal(), m_sketch_tool, and request_repaint().

Here is the call graph for this function:

set_escalate_on_repick()

void Slic3r::GUI::DesignCanvas::set_escalate_on_repick

(

bool

on

)

{
    m_sketch_tool.set_escalate_on_repick(on);
}

References m_sketch_tool.

set_extrude_gizmo()

void Slic3r::GUI::DesignCanvas::set_extrude_gizmo	(	const SketchPlane &	plane,
		const Vec2d &	centroid,
		double	depth,
		double	depth2,
		bool	two_sided,
		bool	flip )

{
    m_sketch_tool.set_extrude_gizmo(plane, centroid, depth, depth2, two_sided, flip);
    request_repaint();
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

set_helix_gizmo()

void Slic3r::GUI::DesignCanvas::set_helix_gizmo	(	const SketchPlane &	plane,
		double	radius,
		double	pitch,
		double	height,
		double	taper,
		bool	left_handed )

{
    m_sketch_tool.set_helix_gizmo(plane, radius, pitch, height, taper, left_handed);
    request_repaint();
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

set_highlight_faces()

void Slic3r::GUI::DesignCanvas::set_highlight_faces

(

const std::vector< std::pair< int, int > > &

faces

)

{
    m_sketch_tool.set_highlight_faces(faces);
    sync_selected_faces();
    request_repaint();
}

References m_sketch_tool, request_repaint(), and sync_selected_faces().

Here is the call graph for this function:

set_highlight_sketches()

void Slic3r::GUI::DesignCanvas::set_highlight_sketches

(

std::vector< std::pair< int, ColorRGBA > >

hl

)

{
    m_sketch_tool.set_highlight_sketches(std::move(hl));
    request_repaint();
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

set_hole_face_bounds()

void Slic3r::GUI::DesignCanvas::set_hole_face_bounds	(	bool	has,
		double	umin,
		double	umax,
		double	vmin,
		double	vmax )

{
    m_sketch_tool.set_hole_face_bounds(has, umin, umax, vmin, vmax);
}

References m_sketch_tool.

set_loop_pick()

void Slic3r::GUI::DesignCanvas::set_loop_pick	(	int	feature,
		int	region )

{
    m_sketch_tool.set_display_pick(feature, region);
    request_repaint();
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

set_mate_connectors()

void Slic3r::GUI::DesignCanvas::set_mate_connectors

(

std::vector< DesignSketchTool::MateConnectorGlyph >

g

)

{
    m_sketch_tool.set_mate_connectors(std::move(g));
    request_repaint();
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

set_mate_links()

void Slic3r::GUI::DesignCanvas::set_mate_links

(

std::vector< std::pair< Vec3d, Vec3d > >

l

)

{
    m_sketch_tool.set_mate_links(std::move(l));
    request_repaint();
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

set_on_body_move_changed()

void Slic3r::GUI::DesignCanvas::set_on_body_move_changed

(

std::function< void(int, const Transform3d &)>

cb

)

{
    m_sketch_tool.on_body_move_changed = std::move(cb);
}

References m_sketch_tool.

set_on_context_menu()

void Slic3r::GUI::DesignCanvas::set_on_context_menu

(

std::function< void(const wxPoint &)>

cb

)

{
    m_on_context_menu = std::move(cb);
    if (!m_canvas_widget || m_ctx_bound)
        return;
    m_ctx_bound = true;
    // Bound AFTER GLCanvas3D's own handlers, so this runs first and can consume the event.
    // It only consumes when it actually opens the offer.
    // Right-drag may pan or orbit (Preferences > Control). Without remembering where the press
    // landed, every such drag ended by popping the offer over wherever the camera stopped — the
    // menu appearing as the reward for moving the view. A right-click is the release of a
    // STATIONARY press (kCadRightClickDriftPx); only that reaches the sketch tool or the offer.
    m_canvas_widget->Bind(wxEVT_RIGHT_DOWN, [this](wxMouseEvent& e) {
        m_ctx_press     = e.GetPosition();
        m_ctx_travelled = false;
        // Drop any press the tool still keeps (only a click's release takes it, so a pan's stays)
        // before the canvas offers it this one, which ImGui may take instead.
        m_sketch_tool.drop_right_click();
        e.Skip();     // the canvas still needs the press to seed a pan or an orbit
    });
    m_canvas_widget->Bind(wxEVT_MOTION, [this](wxMouseEvent& e) {
        if (e.RightIsDown()) {
            const wxPoint d = e.GetPosition() - m_ctx_press;
            if (std::max(std::abs(d.x), std::abs(d.y)) > kCadRightClickDriftPx) m_ctx_travelled = true;
        }
        e.Skip();
    });
    m_canvas_widget->Bind(wxEVT_RIGHT_UP, [this](wxMouseEvent& e) {
        const wxPoint d  = e.GetPosition() - m_ctx_press;
        // Click, or navigation? A press that travelled panned or orbited; one that did not, did not.
        const bool is_click = !m_ctx_travelled && std::max(std::abs(d.x), std::abs(d.y)) <= kCadRightClickDriftPx;
        // Ending a chain or abandoning an anchor uses the click up.
        const bool terminated = is_click && m_canvas && m_sketch_tool.take_right_click(*m_canvas);
        if (terminated)
            m_canvas->set_as_dirty();   // drawn by the canvas's own RightUp (e.Skip below) or at idle
        else if (m_on_context_menu && !inline_busy() && is_click) {
            // The menu belongs to what you POINTED AT — and pointing happened at the PRESS, not
            // at the release, so the raycast uses the press position. Within a 3 px budget the
            // two are the same pixel in practice; using the press is what makes that a
            // guarantee rather than a coincidence. Pick first, so a right-click on a line offers
            // that line's verbs instead of the empty-selection vocabulary. Selecting an entity
            // that is already selected is a no-op, so a multi-entity pick survives a
            // right-click on one of its members.
            if (m_canvas && m_sketch_tool.select_at_screen(*m_canvas, m_ctx_press.x, m_ctx_press.y))
                request_repaint();
            m_on_context_menu(m_canvas_widget->ClientToScreen(m_ctx_press));
            return;   // consumed
        }
        e.Skip();
    });
}

References inline_busy(), Slic3r::GUI::kCadRightClickDriftPx, m_canvas, m_canvas_widget, m_ctx_bound, m_ctx_press, m_ctx_travelled, m_on_context_menu, m_sketch_tool, request_repaint(), and Slic3r::GUI::wxMouseEvent.

Here is the call graph for this function:

set_on_cursor_metrics()

void Slic3r::GUI::DesignCanvas::set_on_cursor_metrics

(

std::function< void(double, double, bool)>

cb

)

{
    m_sketch_tool.on_cursor_metrics = std::move(cb);
}

References m_sketch_tool.

set_on_cut_offset_changed()

void Slic3r::GUI::DesignCanvas::set_on_cut_offset_changed

(

std::function< void(double)>

cb

)

{
    m_sketch_tool.set_on_cut_offset_changed(std::move(cb));
}

References m_sketch_tool.

set_on_datum_base_picked()

void Slic3r::GUI::DesignCanvas::set_on_datum_base_picked

(

std::function< void(int)>

cb

)

{
    m_sketch_tool.on_datum_base_picked = std::move(cb);
}

References m_sketch_tool.

set_on_datum_offset_changed()

void Slic3r::GUI::DesignCanvas::set_on_datum_offset_changed

(

std::function< void(double)>

cb

)

{
    m_sketch_tool.on_datum_offset_changed = std::move(cb);
}

References m_sketch_tool.

set_on_datum_size_changed()

void Slic3r::GUI::DesignCanvas::set_on_datum_size_changed

(

std::function< void(double, double)>

cb

)

{
    m_sketch_tool.on_datum_size_changed = std::move(cb);
}

References m_sketch_tool.

set_on_dimension_pick_complete()

void Slic3r::GUI::DesignCanvas::set_on_dimension_pick_complete

(

std::function< void(double)>

cb

)

{
    m_sketch_tool.on_dimension_pick_complete = std::move(cb);
}

References m_sketch_tool.

set_on_display_sketch_activated()

void Slic3r::GUI::DesignCanvas::set_on_display_sketch_activated

(

std::function< void(int)>

cb

)

{
    m_sketch_tool.on_display_sketch_activated = std::move(cb);
}

References m_sketch_tool.

set_on_display_sketch_selected()

void Slic3r::GUI::DesignCanvas::set_on_display_sketch_selected

(

std::function< void(int, int, int)>

cb

)

{
    m_sketch_tool.on_display_sketch_selected = std::move(cb);
}

References m_sketch_tool.

set_on_draft_angle_changed()

void Slic3r::GUI::DesignCanvas::set_on_draft_angle_changed

(

std::function< void(double)>

cb

)

{
    m_sketch_tool.set_on_draft_angle_changed(std::move(cb));
}

References m_sketch_tool.

set_on_empty_pick()

void Slic3r::GUI::DesignCanvas::set_on_empty_pick

(

std::function< void()>

cb

)

{
    m_sketch_tool.on_empty_pick = std::move(cb);
}

References m_sketch_tool.

set_on_extrude_depth_changed()

void Slic3r::GUI::DesignCanvas::set_on_extrude_depth_changed

(

std::function< void(double, bool)>

cb

)

{
    m_sketch_tool.on_extrude_depth_changed = std::move(cb);
}

References m_sketch_tool.

set_on_fillet_radius_changed()

void Slic3r::GUI::DesignCanvas::set_on_fillet_radius_changed

(

std::function< void(double)>

cb

)

{
    m_sketch_tool.on_fillet_radius_changed = std::move(cb);
}

References m_sketch_tool.

set_on_helix_changed()

void Slic3r::GUI::DesignCanvas::set_on_helix_changed

(

std::function< void(double, double, double)>

cb

)

{
    m_sketch_tool.on_helix_changed = std::move(cb);
}

References m_sketch_tool.

set_on_hole_changed()

void Slic3r::GUI::DesignCanvas::set_on_hole_changed

(

std::function< void(double, double, double, double)>

cb

)

{
    m_sketch_tool.on_hole_changed = std::move(cb);
}

References m_sketch_tool.

set_on_imported_transform()

void Slic3r::GUI::DesignCanvas::set_on_imported_transform

(

std::function< void(int, Vec2d, double, double)>

cb

)

{
    m_sketch_tool.on_imported_transform = std::move(cb);
}

References m_sketch_tool.

set_on_pattern_changed()

void Slic3r::GUI::DesignCanvas::set_on_pattern_changed

(

std::function< void(double)>

cb

)

{
    m_sketch_tool.on_pattern_changed = std::move(cb);
}

References m_sketch_tool.

set_on_revolve_angle_changed()

void Slic3r::GUI::DesignCanvas::set_on_revolve_angle_changed

(

std::function< void(double)>

cb

)

{
    m_sketch_tool.on_revolve_angle_changed = std::move(cb);
}

References m_sketch_tool.

set_on_rib_thickness_changed()

void Slic3r::GUI::DesignCanvas::set_on_rib_thickness_changed

(

std::function< void(double)>

cb

)

{
    m_sketch_tool.on_rib_thickness_changed = std::move(cb);
}

References m_sketch_tool.

set_on_segment_drawn()

void Slic3r::GUI::DesignCanvas::set_on_segment_drawn

(

std::function< void(double, double)>

cb

)

{
    m_sketch_tool.on_segment_drawn = std::move(cb);
}

References m_sketch_tool.

set_on_shell_thickness_changed()

void Slic3r::GUI::DesignCanvas::set_on_shell_thickness_changed

(

std::function< void(double)>

cb

)

{
    m_sketch_tool.on_shell_thickness_changed = std::move(cb);
}

References m_sketch_tool.

set_on_sketch_commit()

void Slic3r::GUI::DesignCanvas::set_on_sketch_commit

(

std::function< void(const SketchProfile &, const SketchPlane &)>

cb

)

{
    m_on_sketch_commit = std::move(cb);
}

References m_on_sketch_commit.

set_on_sketch_constraints_changed()

void Slic3r::GUI::DesignCanvas::set_on_sketch_constraints_changed

(

std::function< void()>

cb

)

{
    m_sketch_tool.on_constraints_changed = std::move(cb);
}

References m_sketch_tool.

set_on_sketch_entities_commit()

void Slic3r::GUI::DesignCanvas::set_on_sketch_entities_commit

(

std::function< void(const std::vector< SketchEntity > &, const std::vector< SketchEntityConstraintDef > &, const SketchPlane &)>

cb

)

{
    m_on_sketch_entities_commit = std::move(cb);
}

References m_on_sketch_entities_commit.

set_on_sketch_exit()

void Slic3r::GUI::DesignCanvas::set_on_sketch_exit

(

std::function< void()>

cb

)

{
    m_sketch_tool.on_exit = std::move(cb);
}

References m_sketch_tool.

set_on_sketch_exit_refused()

void Slic3r::GUI::DesignCanvas::set_on_sketch_exit_refused

(

std::function< void()>

cb

)

{
    m_sketch_tool.on_exit_refused = std::move(cb);
}

References m_sketch_tool.

set_on_sketch_face_selected()

void Slic3r::GUI::DesignCanvas::set_on_sketch_face_selected

(

std::function< void(int)>

cb

)

{
    m_sketch_tool.on_face_selected = std::move(cb);
}

References m_sketch_tool.

set_on_sketch_notice()

void Slic3r::GUI::DesignCanvas::set_on_sketch_notice

(

std::function< void(const std::string &, bool)>

cb

)

{
    m_sketch_tool.on_notice = std::move(cb);
}

References m_sketch_tool.

set_on_sketch_selection_changed()

void Slic3r::GUI::DesignCanvas::set_on_sketch_selection_changed

(

std::function< void(int)>

cb

)

{
    m_sketch_tool.on_selection_changed = std::move(cb);
}

References m_sketch_tool.

set_on_sketch_step()

void Slic3r::GUI::DesignCanvas::set_on_sketch_step

(

std::function< void(DesignSketchTool::Mode, int, int)>

cb

)

{
    m_sketch_tool.on_step_changed = std::move(cb);
}

References m_sketch_tool.

set_on_solid_selection_changed()

void Slic3r::GUI::DesignCanvas::set_on_solid_selection_changed

(

std::function< void(int, int, int, int)>

cb

)

{
    // Wrapped so every pick change in the tool also re-splits the filled faces.
    m_on_solid_selection_changed = std::move(cb);
    m_sketch_tool.on_solid_selection_changed = [this](int level, int body, int face, int edge) {
        sync_selected_faces();
        if (m_on_solid_selection_changed)
            m_on_solid_selection_changed(level, body, face, edge);
    };
}

References m_on_solid_selection_changed, m_sketch_tool, and sync_selected_faces().

Here is the call graph for this function:

set_on_solve_state()

void Slic3r::GUI::DesignCanvas::set_on_solve_state

(

std::function< void(int, bool, bool)>

cb

)

{
    m_sketch_tool.on_solve_state = std::move(cb);
}

References m_sketch_tool.

set_on_thread_changed()

void Slic3r::GUI::DesignCanvas::set_on_thread_changed

(

std::function< void(double, double, double, double)>

cb

)

{
    m_sketch_tool.on_thread_changed = std::move(cb);
}

References m_sketch_tool.

set_operand_bodies()

void Slic3r::GUI::DesignCanvas::set_operand_bodies	(	int	target_body,
		int	tool_body )

{
    if (m_hl_body_target == target_body && m_hl_body_tool == tool_body) return;
    m_hl_body_target = target_body;
    m_hl_body_tool   = tool_body;
    reload();      // recolours the body volumes
}

References m_hl_body_target, m_hl_body_tool, and reload().

Here is the call graph for this function:

set_preview_mesh()

void Slic3r::GUI::DesignCanvas::set_preview_mesh

(

const TriangleMesh &

mesh

)

{
    // Remove existing ghost (object 1) if present
    if (m_model.objects.size() > 1)
        m_model.delete_object((size_t)1);
 
    auto* obj = m_model.add_object();
    obj->add_volume(mesh);
    obj->add_instance();
 
    reload();
}

References m_model, and reload().

Here is the call graph for this function:

set_readout()

void Slic3r::GUI::DesignCanvas::set_readout ( const std::string & text )

private

{
    if (text == m_hud_last) return;
    m_hud_last = text;
    if (m_canvas) m_canvas->set_as_dirty();   // drawn by the next frame (the tool feeds this from one)
}

References m_canvas, and m_hud_last.

Referenced by DesignCanvas().

Here is the caller graph for this function:

set_rib_gizmo()

void Slic3r::GUI::DesignCanvas::set_rib_gizmo	(	const SketchPlane &	plane,
		const Vec2d &	p0,
		const Vec2d &	p1,
		double	thickness )

{
    m_sketch_tool.set_rib_gizmo(plane, p0, p1, thickness);
    request_repaint();
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

set_section_plane()

void Slic3r::GUI::DesignCanvas::set_section_plane	(	bool	on,
		double	z,
		bool	keep_upper = false )

{
    m_section_on = on;
    // The kept half must read as a SOLID part, never a see-through ghost: make sure no leftover
    // preview translucency is applied while the section is on. Guarded — a no-op if already opaque.
    if (on) { set_body_translucent(false); set_body_hidden(false); }
    if (m_canvas) {
        if (on) {
            // GLCanvas3D turns the two clipping planes into a Z-RANGE: set_z_range(-p0.offset,
            // p1.offset). keep_upper=false keeps the LOWER half (z in [-1e5, z]); keep_upper=true
            // keeps the OPPOSITE, UPPER half (z in [z, +1e5]). Only HIDES geometry — no bodies.
            if (keep_upper) {
                m_canvas->set_clipping_plane(0, ClippingPlane(Vec3d(0.0, 0.0, 1.0), -z));     // min_z = z
                m_canvas->set_clipping_plane(1, ClippingPlane(Vec3d(0.0, 0.0, 1.0), 1.0e5));  // max_z = +1e5
            } else {
                m_canvas->set_clipping_plane(0, ClippingPlane(Vec3d(0.0, 0.0, 1.0), 1.0e5));  // min_z = -1e5
                m_canvas->set_clipping_plane(1, ClippingPlane(Vec3d(0.0, 0.0, 1.0), z));      // max_z = z
            }
            m_canvas->set_use_clipping_planes(true);
        } else {
            m_canvas->set_use_clipping_planes(false);
        }
        m_canvas->set_as_dirty();
    }
    request_repaint();
}

References m_canvas, m_section_on, request_repaint(), set_body_hidden(), and set_body_translucent().

Here is the call graph for this function:

set_selected_base()

void Slic3r::GUI::DesignCanvas::set_selected_base

(

std::function< int()>

cb

)

{
    m_sketch_tool.selected_base = std::move(cb);
}

References m_sketch_tool.

set_show_bed()

void Slic3r::GUI::DesignCanvas::set_show_bed

(

bool

b

)

{
    if (!m_canvas) return;
    if (m_canvas->get_show_bed() == b) return;   // no repaint for a no-op toggle
    m_canvas->set_show_bed(b);
    request_repaint();
}

References m_canvas, and request_repaint().

Here is the call graph for this function:

set_sidebar_collapse()

void Slic3r::GUI::DesignCanvas::set_sidebar_collapse	(	std::function< CollapseSide()>	side,
		std::function< void()>	toggle )

{
    if (!m_canvas || !m_canvas_widget || !setup_collapse_toolbar(m_collapse_toolbar, toggle))
        return;
    m_canvas->set_collapse_toolbar(&m_collapse_toolbar, std::move(side));
    m_canvas->enable_collapse_toolbar(true);
    // Shift+Tab: the canvas posts this for its sidebar, as Prepare's canvases do.
    m_canvas_widget->Bind(EVT_GLCANVAS_COLLAPSE_SIDEBAR, [toggle](SimpleEvent&) { toggle(); });
}

References m_canvas, m_canvas_widget, m_collapse_toolbar, and Slic3r::GUI::setup_collapse_toolbar().

Here is the call graph for this function:

set_sidebar_collapse_tooltip()

void Slic3r::GUI::DesignCanvas::set_sidebar_collapse_tooltip

(

const std::string &

tooltip

)

{
    m_collapse_toolbar.set_tooltip(m_collapse_toolbar.get_item_id("collapse_sidebar"), tooltip);
}

References m_collapse_toolbar.

set_sketch_construction()

void Slic3r::GUI::DesignCanvas::set_sketch_construction

(

bool

c

)

{
    m_sketch_tool.set_construction(c);
}

References m_sketch_tool.

set_sketch_dimension_value()

void Slic3r::GUI::DesignCanvas::set_sketch_dimension_value

(

double

v

)

{
    m_sketch_tool.set_dimension_value(v);
    request_repaint();
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

set_sketch_polygon_circumscribed()

void Slic3r::GUI::DesignCanvas::set_sketch_polygon_circumscribed

(

bool

c

)

{
    m_sketch_tool.set_polygon_circumscribed(c);
}

References m_sketch_tool.

set_sketch_polygon_sides()

void Slic3r::GUI::DesignCanvas::set_sketch_polygon_sides

(

int

n

)

{
    m_sketch_tool.set_polygon_sides(n);
}

References m_sketch_tool.

set_sketch_tool()

void Slic3r::GUI::DesignCanvas::set_sketch_tool

(

DesignSketchTool::Mode

mode

)

{
    m_sketch_tool.set_tool(mode);
    if (m_canvas) m_canvas->set_as_dirty();
    if (m_canvas_widget) m_canvas_widget->Refresh();
}

References m_canvas, m_canvas_widget, and m_sketch_tool.

set_solid_pick()

void Slic3r::GUI::DesignCanvas::set_solid_pick	(	const std::vector< CadBody > *	bodies,
		const TriangleMesh *	mesh,
		const std::vector< int > *	tri_face,
		const std::vector< int > *	tri_body,
		const std::vector< bool > *	visible = nullptr,
		const std::vector< Transform3d > *	xform = nullptr )

{
    m_color_bodies = bodies;   // stable address (m_doc.bodies); reload() reads colour overrides
    m_tri_face     = tri_face;
    m_sketch_tool.set_solid_pick(bodies, mesh, tri_face, tri_body, visible, xform);
    sync_selected_faces();     // the tool just reset its pick
}

References m_color_bodies, m_sketch_tool, m_tri_face, and sync_selected_faces().

Here is the call graph for this function:

set_status_text()

void Slic3r::GUI::DesignCanvas::set_status_text	(	const wxString &	text,
		const wxColour &	colour )

{
    if (text == m_status_hud_last && colour == m_status_hud_colour) return;
    m_status_hud_last   = text;
    m_status_hud_colour = colour;
    request_repaint();
}

References m_status_hud_colour, m_status_hud_last, and request_repaint().

Here is the call graph for this function:

set_view()

void Slic3r::GUI::DesignCanvas::set_view

(

const std::string &

view_name

)

{
    if (m_canvas) {
        if (view_name == "iso")
            select_iso_view(wxGetApp().plater()->get_camera());   // the Design camera while the tab is shown
        else
            m_canvas->select_view(view_name);
        m_canvas->zoom_to_volumes();
        m_canvas->set_as_dirty();
        if (m_canvas_widget)
            m_canvas_widget->Refresh();
    }
}

References m_canvas, m_canvas_widget, Slic3r::GUI::plater(), and Slic3r::GUI::select_iso_view().

Here is the call graph for this function:

set_xray_focus()

void Slic3r::GUI::DesignCanvas::set_xray_focus

(

int

body

)

{
    if (m_xray_focus == body) return;
    m_xray_focus = body;
    m_sketch_tool.set_pick_only_body(body);
    reload();   // re-applies per-body alpha so the non-focused bodies fade
}

References m_sketch_tool, m_xray_focus, and reload().

Here is the call graph for this function:

shelling()

bool Slic3r::GUI::DesignCanvas::shelling

(

)

const

{ return m_sketch_tool.shelling(); }

References m_sketch_tool.

sketch_abort_gesture()

bool Slic3r::GUI::DesignCanvas::sketch_abort_gesture

(

)

{
    if (!m_sketch_tool.abort_gesture()) return false;
    request_repaint();     // the rubber band is gone; the canvas must stop drawing it
    return true;
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

sketch_confirm_pending()

bool Slic3r::GUI::DesignCanvas::sketch_confirm_pending

(

)

{
    if (!m_sketch_tool.confirm_pending()) return false;
    request_repaint();
    return true;
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

sketch_constraint_count()

int Slic3r::GUI::DesignCanvas::sketch_constraint_count

(

)

const

{
    return int(m_sketch_tool.constraints().size());
}

References m_sketch_tool.

sketch_constraints()

const std::vector< SketchEntityConstraintDef > & Slic3r::GUI::DesignCanvas::sketch_constraints

(

)

const

{
    return m_sketch_tool.constraints();
}

References m_sketch_tool.

sketch_dimension_current()

double Slic3r::GUI::DesignCanvas::sketch_dimension_current

(

)

const

{
    return m_sketch_tool.dimension_current();
}

References m_sketch_tool.

sketch_dimension_kind()

DesignSketchTool::DimType Slic3r::GUI::DesignCanvas::sketch_dimension_kind

(

)

const

{
    return m_sketch_tool.dimension_kind();
}

References m_sketch_tool.

sketch_disarm_tool()

bool Slic3r::GUI::DesignCanvas::sketch_disarm_tool

(

)

{
    if (!m_sketch_tool.disarm_tool()) return false;
    request_repaint();
    return true;
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

sketch_entities()

const std::vector< SketchEntity > & Slic3r::GUI::DesignCanvas::sketch_entities

(

)

const

{
    return m_sketch_tool.entities();
}

References m_sketch_tool.

sketch_first_selected_type()

bool Slic3r::GUI::DesignCanvas::sketch_first_selected_type

(

SketchEntity::Type &

out

)

const

{
    return m_sketch_tool.first_selected_type(out);
}

References m_sketch_tool.

sketch_is_selecting()

bool Slic3r::GUI::DesignCanvas::sketch_is_selecting ( ) const

inline

{ return m_sketch_tool.mode() == DesignSketchTool::Mode::Select; }

References m_sketch_tool, and Slic3r::GUI::DesignSketchTool::Select.

sketch_selection()

const std::vector< int > & Slic3r::GUI::DesignCanvas::sketch_selection

(

)

const

{
    return m_sketch_tool.selection();
}

References m_sketch_tool.

sketch_selection_count()

int Slic3r::GUI::DesignCanvas::sketch_selection_count

(

)

const

{
    return int(m_sketch_tool.selection().size());
}

References m_sketch_tool.

swap_camera()

void Slic3r::GUI::DesignCanvas::swap_camera ( )

private

{
    Plater* plater = wxGetApp().plater();
    if (plater == nullptr) return;
    std::swap(plater->get_camera(), m_parked_camera);
    m_camera_swapped = !m_camera_swapped;
}

References m_camera_swapped, m_parked_camera, and Slic3r::GUI::plater().

Referenced by enter_viewport(), and leave_viewport().

Here is the call graph for this function:

Here is the caller graph for this function:

sync_selected_faces()

void Slic3r::GUI::DesignCanvas::sync_selected_faces ( )

private

{
    // Deferred to the end of the current event, which may change the selection several times:
    // every re-split reloads all the bodies. A set_bodies in between splits by the current
    // selection itself and leaves this nothing to do.
    if (m_split_pending)
        return;
    m_split_pending = true;
    CallAfter([this] {
        m_split_pending = false;
        std::vector<std::pair<int, int>> want = m_sketch_tool.selected_faces();
        if (want == m_lit_faces)
            return;
        m_lit_faces = std::move(want);
        if (m_body_meshes == nullptr || m_model.objects.empty())
            return;
        rebuild_bodies();
        reload();
    });
}

References m_body_meshes, m_lit_faces, m_model, m_sketch_tool, m_split_pending, rebuild_bodies(), and reload().

Referenced by clear_solid_pick(), select_body(), set_highlight_faces(), set_on_solid_selection_changed(), and set_solid_pick().

Here is the call graph for this function:

Here is the caller graph for this function:

threading()

bool Slic3r::GUI::DesignCanvas::threading

(

)

const

{ return m_sketch_tool.threading(); }

References m_sketch_tool.

toggle_axes()

bool Slic3r::GUI::DesignCanvas::toggle_axes

(

)

{
    const bool on = m_sketch_tool.toggle_show_axes();
    request_repaint();
    return on;
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

toggle_planes()

bool Slic3r::GUI::DesignCanvas::toggle_planes

(

)

{
    const bool on = m_sketch_tool.toggle_show_planes();
    request_repaint();
    return on;
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

toggle_sketch_construction_selection()

int Slic3r::GUI::DesignCanvas::toggle_sketch_construction_selection

(

)

{
    const int n = m_sketch_tool.toggle_selection_construction();
    if (n > 0) request_repaint();
    return n;
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

try_add_sketch_constraints()

bool Slic3r::GUI::DesignCanvas::try_add_sketch_constraints

(

const std::vector< SketchEntityConstraintDef > &

defs

)

{
    return m_sketch_tool.try_add_constraints(defs);
}

References m_sketch_tool.

unbind_canvas_event_handlers()

void Slic3r::GUI::DesignCanvas::unbind_canvas_event_handlers

(

)

{
    if (m_canvas) m_canvas->unbind_event_handlers();
}

References m_canvas.

undo_last_sketch_entity()

bool Slic3r::GUI::DesignCanvas::undo_last_sketch_entity

(

)

{
    const bool did = m_sketch_tool.undo_last_entity();
    if (did) request_repaint();
    return did;
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

update_constrain_entities()

void Slic3r::GUI::DesignCanvas::update_constrain_entities

(

const std::vector< SketchEntity > &

ents

)

{
    m_sketch_tool.set_constrain_entities(ents);
    request_repaint();
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

update_constrain_profile()

void Slic3r::GUI::DesignCanvas::update_constrain_profile

(

const std::vector< Vec2d > &

pts

)

{
    m_sketch_tool.set_profile_points(pts);
    request_repaint();
}

References m_sketch_tool, and request_repaint().

Here is the call graph for this function:

view_normal_to_sketch()

bool Slic3r::GUI::DesignCanvas::view_normal_to_sketch

(

)

{
    if (m_canvas == nullptr) return false;
    const SketchPlane& pl = m_sketch_tool.plane();
    Camera& cam = wxGetApp().plater()->get_camera();
    // Keep the distance: this is an orientation change, not a zoom. The plane's own y axis is
    // the up vector, so "up" on screen is up in sketch coordinates — which is what makes a
    // dimension typed after pressing N land where the eye expects it.
    const double dist = cam.get_distance();
    cam.look_at(pl.origin + pl.normal * dist, pl.origin, pl.y_axis);
    request_repaint();
    return true;
}

References Slic3r::Geometry::dist(), Slic3r::GUI::Camera::get_distance(), Slic3r::GUI::Camera::look_at(), m_canvas, m_sketch_tool, Slic3r::SketchPlane::normal, Slic3r::SketchPlane::origin, request_repaint(), and Slic3r::SketchPlane::y_axis.

Here is the call graph for this function:

zoom_to_box()

bool Slic3r::GUI::DesignCanvas::zoom_to_box

(

BoundingBoxf3

box

)

{
    if (m_canvas == nullptr || !box.defined)
        return false;
    DesignSketchTool::pad_box(box);
    m_canvas->zoom_to_box(box);
    request_repaint();
    return true;
}

References Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::defined, m_canvas, Slic3r::GUI::DesignSketchTool::pad_box(), and request_repaint().

Here is the call graph for this function:

Member Data Documentation

m_bed

Bed3D Slic3r::GUI::DesignCanvas::m_bed

private

Referenced by DesignCanvas(), bed_center(), and refresh_bed().

m_body_hidden

bool Slic3r::GUI::DesignCanvas::m_body_hidden {false}

private

{false};     // preview-only mode → hide base bodies, ghost = the result

Referenced by reload(), and set_body_hidden().

m_body_meshes

const std::vector<TriangleMesh>* Slic3r::GUI::DesignCanvas::m_body_meshes {nullptr}

private

{nullptr};  // set_bodies

Referenced by clear_mesh(), rebuild_bodies(), set_bodies(), and sync_selected_faces().

m_body_translucent

bool Slic3r::GUI::DesignCanvas::m_body_translucent {false}

private

{false};// fillet/chamfer preview → render the body see-through

Referenced by reload(), and set_body_translucent().

m_body_visible

std::vector<bool> Slic3r::GUI::DesignCanvas::m_body_visible

private

Referenced by reload(), and set_bodies().

m_camera_swapped

bool Slic3r::GUI::DesignCanvas::m_camera_swapped {false}

private

{false};   // guards a leave without an enter, and the reverse

Referenced by enter_viewport(), leave_viewport(), and swap_camera().

m_canvas

GLCanvas3D* Slic3r::GUI::DesignCanvas::m_canvas {nullptr}

private

{nullptr};

Referenced by DesignCanvas(), ~DesignCanvas(), begin_sketch(), cancel_sketch(), edit_sketch(), enter_viewport(), finish_sketch(), fit_view(), force_repaint(), reload(), render_hud(), repaint_now(), request_repaint(), reset_canvas_volumes(), set_on_context_menu(), set_readout(), set_section_plane(), set_show_bed(), set_sidebar_collapse(), set_sketch_tool(), set_view(), unbind_canvas_event_handlers(), view_normal_to_sketch(), and zoom_to_box().

m_canvas_widget

wxGLCanvas* Slic3r::GUI::DesignCanvas::m_canvas_widget {nullptr}

private

{nullptr};

Referenced by DesignCanvas(), ~DesignCanvas(), begin_sketch(), cancel_sketch(), edit_sketch(), finish_sketch(), fit_view(), force_repaint(), open_inline_value(), reload(), repaint_now(), request_repaint(), set_on_context_menu(), set_sidebar_collapse(), set_sketch_tool(), and set_view().

m_collapse_toolbar

GLToolbar Slic3r::GUI::DesignCanvas::m_collapse_toolbar {GLToolbar::Normal, "Collapse"}

private

{GLToolbar::Normal, "Collapse"};

Referenced by set_sidebar_collapse(), and set_sidebar_collapse_tooltip().

m_color_bodies

const std::vector<CadBody>* Slic3r::GUI::DesignCanvas::m_color_bodies {nullptr}

private

{nullptr};

Referenced by body_color(), and set_solid_pick().

m_ctx_bound

bool Slic3r::GUI::DesignCanvas::m_ctx_bound {false}

private

{false};   // bind the RIGHT_UP handler once, however often the cb is set

Referenced by set_on_context_menu().

m_ctx_press

wxPoint Slic3r::GUI::DesignCanvas::m_ctx_press {0, 0}

private

{0, 0};    // right-press origin: a right-DRAG orbits, it must not offer

Referenced by set_on_context_menu().

m_ctx_travelled

bool Slic3r::GUI::DesignCanvas::m_ctx_travelled {false}

private

{false};   // the right press wandered past the budget at ANY point,

Referenced by set_on_context_menu().

m_hl_body_target

int Slic3r::GUI::DesignCanvas::m_hl_body_target {-1}

private

{-1};

Referenced by reload(), and set_operand_bodies().

m_hl_body_tool

int Slic3r::GUI::DesignCanvas::m_hl_body_tool {-1}

private

{-1};

Referenced by reload(), and set_operand_bodies().

m_hud_last

std::string Slic3r::GUI::DesignCanvas::m_hud_last

private

Referenced by render_hud(), and set_readout().

m_inline_editor

std::unique_ptr<SketchInlineEditor> Slic3r::GUI::DesignCanvas::m_inline_editor

private

Referenced by DesignCanvas(), inline_busy(), inline_cancel(), inline_commit(), inline_has_focus(), and open_inline_value().

m_lit_faces

std::vector<std::pair<int, int> > Slic3r::GUI::DesignCanvas::m_lit_faces

private

Referenced by rebuild_bodies(), set_bodies(), and sync_selected_faces().

m_model

Model Slic3r::GUI::DesignCanvas::m_model

private

Referenced by DesignCanvas(), clear_mesh(), clear_preview(), fit_view(), model_mid_z(), rebuild_bodies(), reload(), set_preview_mesh(), and sync_selected_faces().

m_on_context_menu

std::function<void(const wxPoint&)> Slic3r::GUI::DesignCanvas::m_on_context_menu

private

Referenced by set_on_context_menu().

m_on_sketch_commit

std::function<void(const SketchProfile&, const SketchPlane&)> Slic3r::GUI::DesignCanvas::m_on_sketch_commit

private

Referenced by DesignCanvas(), and set_on_sketch_commit().

m_on_sketch_entities_commit

std::function<void(const std::vector<SketchEntity>&, const std::vector<SketchEntityConstraintDef>&, const SketchPlane&)> Slic3r::GUI::DesignCanvas::m_on_sketch_entities_commit

private

Referenced by DesignCanvas(), and set_on_sketch_entities_commit().

m_on_solid_selection_changed

std::function<void(int, int, int, int)> Slic3r::GUI::DesignCanvas::m_on_solid_selection_changed

private

Referenced by set_on_solid_selection_changed().

m_parked_camera

Camera Slic3r::GUI::DesignCanvas::m_parked_camera

private

Referenced by DesignCanvas(), and swap_camera().

m_section_on

bool Slic3r::GUI::DesignCanvas::m_section_on {false}

private

{false};

Referenced by set_section_plane().

m_sketch_tool

DesignSketchTool Slic3r::GUI::DesignCanvas::m_sketch_tool

private

Referenced by DesignCanvas(), add_sketch_regions(), apply_segment_length(), apply_sketch_dimension(), begin_constrain(), begin_constrain_entities(), begin_fillet_gizmo(), begin_hole_gizmo(), begin_imported_transform(), begin_move_body(), begin_pattern_gizmo(), begin_revolve_gizmo(), begin_shell_gizmo(), begin_sketch(), begin_thread_gizmo(), can_redo_sketch_entity(), can_undo_sketch_entity(), cancel_sketch(), cancel_sketch_dimension(), clear_any_selection(), clear_base_pick(), clear_cut_gizmo(), clear_datum_gizmo(), clear_draft_gizmo(), clear_extrude_gizmo(), clear_fillet_gizmo(), clear_helix_gizmo(), clear_hole_gizmo(), clear_loop_pick(), clear_mesh(), clear_move_gizmo(), clear_pattern_gizmo(), clear_revolve_gizmo(), clear_rib_gizmo(), clear_shell_gizmo(), clear_sketch_selection(), clear_solid_pick(), clear_thread_gizmo(), cutting(), delete_selected_sketch_entities(), drafting(), drawing_in_progress(), edit_sketch(), edit_sketch_selection_value(), end_constrain(), faces_box(), filleting(), finish_sketch(), has_any_selection(), holing(), inline_busy(), is_constraining(), is_constraining_entities(), is_sketching(), keep_segment_as_drawn(), live_sketch_has_work(), loop_pick_feature(), loop_pick_region(), mcp_sketch_tool(), mcp_sketch_tool(), open_inline_value(), patterning(), pending_dimension_type(), pick0_point(), redo_last_sketch_entity(), region_entity_indices(), region_entity_indices_with_holes(), remove_sketch_constraint(), request_sketch_exit(), revolving(), select_body(), selected_constrain_axis(), selected_constrain_entities(), selected_loop_entities(), selected_segment(), selected_solid_edges(), selection_box(), set_base_pick(), set_bodies(), set_body_hidden(), set_constraint_glyphs(), set_constraint_highlight(), set_cut_gizmo(), set_datum_gizmo(), set_datum_planes(), set_display_sketches(), set_draft_gizmo(), set_escalate_on_repick(), set_extrude_gizmo(), set_helix_gizmo(), set_highlight_faces(), set_highlight_sketches(), set_hole_face_bounds(), set_loop_pick(), set_mate_connectors(), set_mate_links(), set_on_body_move_changed(), set_on_context_menu(), set_on_cursor_metrics(), set_on_cut_offset_changed(), set_on_datum_base_picked(), set_on_datum_offset_changed(), set_on_datum_size_changed(), set_on_dimension_pick_complete(), set_on_display_sketch_activated(), set_on_display_sketch_selected(), set_on_draft_angle_changed(), set_on_empty_pick(), set_on_extrude_depth_changed(), set_on_fillet_radius_changed(), set_on_helix_changed(), set_on_hole_changed(), set_on_imported_transform(), set_on_pattern_changed(), set_on_revolve_angle_changed(), set_on_rib_thickness_changed(), set_on_segment_drawn(), set_on_shell_thickness_changed(), set_on_sketch_constraints_changed(), set_on_sketch_exit(), set_on_sketch_exit_refused(), set_on_sketch_face_selected(), set_on_sketch_notice(), set_on_sketch_selection_changed(), set_on_sketch_step(), set_on_solid_selection_changed(), set_on_solve_state(), set_on_thread_changed(), set_rib_gizmo(), set_selected_base(), set_sketch_construction(), set_sketch_dimension_value(), set_sketch_polygon_circumscribed(), set_sketch_polygon_sides(), set_sketch_tool(), set_solid_pick(), set_xray_focus(), shelling(), sketch_abort_gesture(), sketch_confirm_pending(), sketch_constraint_count(), sketch_constraints(), sketch_dimension_current(), sketch_dimension_kind(), sketch_disarm_tool(), sketch_entities(), sketch_first_selected_type(), sketch_is_selecting(), sketch_selection(), sketch_selection_count(), sync_selected_faces(), threading(), toggle_axes(), toggle_planes(), toggle_sketch_construction_selection(), try_add_sketch_constraints(), undo_last_sketch_entity(), update_constrain_entities(), update_constrain_profile(), and view_normal_to_sketch().

m_split_pending

bool Slic3r::GUI::DesignCanvas::m_split_pending {false}

private

{false};

Referenced by sync_selected_faces().

m_status_hud_colour

wxColour Slic3r::GUI::DesignCanvas::m_status_hud_colour

private

Referenced by render_hud(), and set_status_text().

m_status_hud_last

wxString Slic3r::GUI::DesignCanvas::m_status_hud_last

private

Referenced by render_hud(), and set_status_text().

m_sw_gl

int Slic3r::GUI::DesignCanvas::m_sw_gl {-1}

private

{-1};   // -1 unknown, 0 hardware GL, 1 software GL

Referenced by request_repaint().

m_tri_face

const std::vector<int>* Slic3r::GUI::DesignCanvas::m_tri_face {nullptr}

private

{nullptr};     // per-triangle face id, all bodies in order

Referenced by rebuild_bodies(), and set_solid_pick().

m_volumes

std::vector<BodyVolume> Slic3r::GUI::DesignCanvas::m_volumes

private

Referenced by clear_mesh(), rebuild_bodies(), and reload().

m_xray_focus

int Slic3r::GUI::DesignCanvas::m_xray_focus {-1}

private

{-1};          // >=0: only this body is opaque+clickable (CoordSys picking)

Referenced by reload(), and set_xray_focus().

---

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

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