Slic3r::GUI::SketchInlineEditor Class Reference

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

Collaboration diagram for Slic3r::GUI::SketchInlineEditor:

Classes
struct	Closed

Public Member Functions
	SketchInlineEditor ()=default
void	open (const wxPoint &canvas_px, double value, const std::string &title, std::function< void(double)> on_commit, std::function< void()> on_cancel)
void	close ()
void	cancel ()
void	commit ()
bool	refuse (const std::string &why)
bool	is_open () const
bool	render (ImGuiWrapper &imgui, float scale)
void	bring_to_front ()
bool	is_mapped () const
bool	has_focus () const
void	dismiss ()

Public Attributes
std::function< void()>	request_frame

Private Member Functions
void	do_commit ()
void	do_cancel ()

Private Attributes
std::function< void(double)>	m_commit
std::function< void()>	m_cancel
bool	m_open {false}
bool	m_focus_pending {false}
wxPoint	m_anchor {0, 0}
std::string	m_title
std::string	m_err
char	m_buf [64] {}
double	m_prefill_value {0.0}
std::string	m_prefill_text
bool	m_active {false}
Closed	m_last
bool	m_in_commit {false}

Detailed Description

---

Class Documentation

Slic3r::GUI::SketchInlineEditor::Closed

struct Slic3r::GUI::SketchInlineEditor::Closed

Collaboration diagram for Slic3r::GUI::SketchInlineEditor::Closed:

Class Members
wxPoint	anchor
string	buf
function< void()>	cancel
function< void(double)>	commit
string	prefill_text
double	prefill_value {0.0}
string	title

Constructor & Destructor Documentation

SketchInlineEditor()

Slic3r::GUI::SketchInlineEditor::SketchInlineEditor ( )

default

Member Function Documentation

bring_to_front()

void Slic3r::GUI::SketchInlineEditor::bring_to_front

(

)

{
    // Not gated on m_open: a commit closes the field after it was drawn, and that frame still
    // shows it. A window that did not Begin this frame is not rendered, so lifting it is inert.
    if (ImGuiWindow* w = ImGui::FindWindowByName(kWindowName))
        ImGui::BringWindowToDisplayFront(w);
}

cancel()

void Slic3r::GUI::SketchInlineEditor::cancel

(

)

{
    if (m_open) do_cancel();
}

References do_cancel(), and m_open.

Here is the call graph for this function:

close()

void Slic3r::GUI::SketchInlineEditor::close

(

)

{
    m_open          = false;
    m_focus_pending = false;
    m_active        = false;
    m_commit        = nullptr;
    m_cancel        = nullptr;
    m_err.clear();
}

References m_active, m_cancel, m_commit, m_err, m_focus_pending, and m_open.

Referenced by dismiss(), do_cancel(), and do_commit().

Here is the caller graph for this function:

commit()

void Slic3r::GUI::SketchInlineEditor::commit

(

)

{
    if (m_open) do_commit();
}

References do_commit(), and m_open.

Here is the call graph for this function:

dismiss()

void Slic3r::GUI::SketchInlineEditor::dismiss ( )

inline

{ close(); }

References close().

Here is the call graph for this function:

do_cancel()

void Slic3r::GUI::SketchInlineEditor::do_cancel ( )

private

{
    ux_trace("cancel", m_title, "");
    auto cb = m_cancel;
    close();
    if (cb) cb();
}

References close(), m_cancel, and m_title.

Referenced by cancel(), and render().

Here is the call graph for this function:

Here is the caller graph for this function:

do_commit()

void Slic3r::GUI::SketchInlineEditor::do_commit ( )

private

{
    double v = 0.0;
    // An untouched field commits the value it opened with, not its rounded display: Enter on a
    // 37.4567 line must not turn it into a 37.457 driving dimension.
    if (m_prefill_text == m_buf)
        v = m_prefill_value;
    else if (!parse_value(m_buf, v)) {
        // Refusing input in silence is indistinguishable from the app having frozen: the field
        // just sits there and the user has no idea what it wants. Say so in the title line and
        // keep editing.
        ux_trace("refused", m_title, std::string("typed=") + m_buf);
        m_err = (m_buf[0] == '\0') ? _u8L("Enter a number") : _u8L("Not a number");
        m_focus_pending = true;
        return;
    }
    ux_trace("commit", m_title, std::string("typed=") + m_buf + " value=" + fmt_value(v, 4));
    auto cb = m_commit;
    m_last = Closed{ m_anchor, m_title, std::string(m_buf), m_commit, m_cancel, m_prefill_value, m_prefill_text };
    close();
    // AFTER close(): the callback may open the next queued dimension (a rectangle queues Width
    // then Height), and doing that into a field that still believes it is open would drop the
    // second one's prefill on the floor.
    m_in_commit = true;
    if (cb) cb(v);
    m_in_commit = false;
    m_last = Closed{};
}

References _u8L, close(), m_anchor, m_buf, m_cancel, m_commit, m_err, m_focus_pending, m_in_commit, m_last, m_prefill_text, m_prefill_value, and m_title.

Referenced by commit(), and render().

Here is the call graph for this function:

Here is the caller graph for this function:

has_focus()

bool Slic3r::GUI::SketchInlineEditor::has_focus ( ) const

inline

{ return m_open && (m_active || m_focus_pending); }

References m_active, m_focus_pending, and m_open.

is_mapped()

bool Slic3r::GUI::SketchInlineEditor::is_mapped ( ) const

inline

{ return m_open; }

References m_open.

is_open()

bool Slic3r::GUI::SketchInlineEditor::is_open ( ) const

inline

{ return m_open; }

References m_open.

open()

void Slic3r::GUI::SketchInlineEditor::open	(	const wxPoint &	canvas_px,
		double	value,
		const std::string &	title,
		std::function< void(double)>	on_commit,
		std::function< void()>	on_cancel )

{
    m_anchor = canvas_px;
    m_title  = title;
    m_err.clear();
    m_commit = std::move(on_commit);
    m_cancel = std::move(on_cancel);
    const std::string v = fmt_value(value);
    std::snprintf(m_buf, sizeof(m_buf), "%s", v.c_str());
    m_prefill_value = value;
    m_prefill_text  = v;
    m_active        = false;
    m_open          = true;
    // ImGui takes keyboard focus for one frame on request; asking on the frame the field first
    // appears is what makes typing land without a click. There is no window manager to consult.
    m_focus_pending = true;
    ux_trace("open", m_title, "prefill=" + v);
}

References m_active, m_anchor, m_buf, m_cancel, m_commit, m_err, m_focus_pending, m_open, m_prefill_text, m_prefill_value, and m_title.

refuse()

bool Slic3r::GUI::SketchInlineEditor::refuse

(

const std::string &

why

)

{
    // Only meaningful while a commit callback runs and before it opened another field.
    if (!m_in_commit || m_open) return false;
    m_anchor        = m_last.anchor;
    m_title         = m_last.title;
    m_commit        = m_last.commit;
    m_cancel        = m_last.cancel;
    m_prefill_value = m_last.prefill_value;
    m_prefill_text  = m_last.prefill_text;
    std::snprintf(m_buf, sizeof(m_buf), "%s", m_last.buf.c_str());
    m_err           = why;
    m_open          = true;
    m_focus_pending = true;
    ux_trace("refused", m_title, "reason=" + why);
    return true;
}

References m_anchor, m_buf, m_cancel, m_commit, m_err, m_focus_pending, m_in_commit, m_last, m_open, m_prefill_text, m_prefill_value, and m_title.

render()

bool Slic3r::GUI::SketchInlineEditor::render	(	ImGuiWrapper &	imgui,
		float	scale )

{
    if (!m_open) return false;
 
    ImGuiWrapper::push_common_window_style(scale);
    imgui.set_next_window_pos((float) m_anchor.x, (float) m_anchor.y, ImGuiCond_Always, 0.5f, 0.5f);
    ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 3.0f);
    // NoInputs is what every other sketch overlay sets and is exactly what this one must not:
    // it is the only overlay in the tab that the user types into.
    imgui.begin(std::string(kWindowName),
                ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoDecoration
                    | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoSavedSettings);
 
    if (!m_title.empty() || !m_err.empty()) {
        if (m_err.empty()) {
            imgui.text(m_title);
        } else {
            ImGui::PushStyleColor(ImGuiCol_Text, ImGuiWrapper::to_ImVec4(ColorRGBA(0.91f, 0.42f, 0.42f, 1.0f)));
            imgui.text(m_err);
            ImGui::PopStyleColor();
        }
    }
 
    if (m_focus_pending) {
        ImGui::SetKeyboardFocusHere();
        m_focus_pending = false;
    }
    ImGui::PushItemWidth(90.0f * scale);
    // EnterReturnsTrue so Enter commits from inside the widget; AutoSelectAll so the prefill is
    // replaced by the first digit typed, which is what "pre-selected" meant when this was a
    // wxTextCtrl and is what makes typing a value a single gesture.
    // No CharsDecimal: it lets only the LOCALE's decimal separator through, so in a C locale a
    // comma could not be typed at all, and it admits '*' and '/' that the parser then refuses.
    // parse_value() is the one judge of what is a number.
    const bool entered = ImGui::InputText("##sketchvalue_in", m_buf, sizeof(m_buf),
                                          ImGuiInputTextFlags_EnterReturnsTrue
                                              | ImGuiInputTextFlags_AutoSelectAll);
    m_active = ImGui::IsItemActive();
    // Tab accepts the value like Enter does (and moves on to the next queued field, if any).
    const bool tabbed = m_active && ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_Tab));
    // MEASUREMENT, not a fix: one line per frame saying whether ImGui believes it owns the
    // keyboard and whether our widget is the active one. "Typing does not arrive" has two very
    // different causes — no FRAMES (this canvas repaints on demand only, so an idle canvas never
    // processes ImGui's queued characters) versus frames that run while the input is not active —
    // and they are indistinguishable from outside.
    if (std::getenv("ORCA_CAD_UXTRACE")) {
        const ImGuiIO& io = ImGui::GetIO();
        std::fprintf(stderr, "[UX] frame title=%s want_text=%d want_kb=%d active=%d buf=%s\n",
                     m_title.c_str(), (int) io.WantTextInput, (int) io.WantCaptureKeyboard,
                     (int) ImGui::IsItemActive(), m_buf);
        std::fflush(stderr);
    }
    ImGui::PopItemWidth();
    imgui.end();
    ImGui::PopStyleVar();
    ImGuiWrapper::pop_common_window_style();
 
    // Keep the frames coming while the field is up — see request_frame's note in the header.
    if (m_open && request_frame)
        request_frame();
 
    // Act AFTER end(): do_commit can reopen the field for the next queued dimension, and that
    // must not happen inside this frame's window.
    if (entered || tabbed)
        do_commit();
    else if (ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_Escape)))
        do_cancel();
    return true;
}

References Slic3r::GUI::ImGuiWrapper::begin(), do_cancel(), do_commit(), Slic3r::GUI::ImGuiWrapper::end(), m_active, m_anchor, m_buf, m_err, m_focus_pending, m_open, m_title, Slic3r::GUI::ImGuiWrapper::pop_common_window_style(), Slic3r::GUI::ImGuiWrapper::push_common_window_style(), request_frame, scale(), Slic3r::GUI::ImGuiWrapper::set_next_window_pos(), Slic3r::GUI::ImGuiWrapper::text(), and Slic3r::GUI::ImGuiWrapper::to_ImVec4().

Here is the call graph for this function:

Member Data Documentation

m_active

bool Slic3r::GUI::SketchInlineEditor::m_active {false}

private

{false};         // the InputText was the active item last frame

Referenced by close(), has_focus(), open(), and render().

m_anchor

wxPoint Slic3r::GUI::SketchInlineEditor::m_anchor {0, 0}

private

{0, 0};          // canvas device px

Referenced by do_commit(), open(), refuse(), and render().

m_buf

char Slic3r::GUI::SketchInlineEditor::m_buf[64] {}

private

{};             // the edited text; ImGui::InputText writes into it

Referenced by do_commit(), open(), refuse(), and render().

m_cancel

std::function<void()> Slic3r::GUI::SketchInlineEditor::m_cancel

private

Referenced by close(), do_cancel(), do_commit(), open(), and refuse().

m_commit

std::function<void(double)> Slic3r::GUI::SketchInlineEditor::m_commit

private

Referenced by close(), do_commit(), open(), and refuse().

m_err

std::string Slic3r::GUI::SketchInlineEditor::m_err

private

Referenced by close(), do_commit(), open(), refuse(), and render().

m_focus_pending

bool Slic3r::GUI::SketchInlineEditor::m_focus_pending {false}

private

{false};  // one frame of SetKeyboardFocusHere after opening

Referenced by close(), do_commit(), has_focus(), open(), refuse(), and render().

m_in_commit

bool Slic3r::GUI::SketchInlineEditor::m_in_commit {false}

private

{false};

Referenced by do_commit(), and refuse().

m_last

Closed Slic3r::GUI::SketchInlineEditor::m_last

private

Referenced by do_commit(), and refuse().

m_open

bool Slic3r::GUI::SketchInlineEditor::m_open {false}

private

{false};

Referenced by cancel(), close(), commit(), has_focus(), is_mapped(), is_open(), open(), refuse(), and render().

m_prefill_text

std::string Slic3r::GUI::SketchInlineEditor::m_prefill_text

private

Referenced by do_commit(), open(), and refuse().

m_prefill_value

double Slic3r::GUI::SketchInlineEditor::m_prefill_value {0.0}

private

{0.0};    // the exact value the field opened with...

Referenced by do_commit(), open(), and refuse().

m_title

std::string Slic3r::GUI::SketchInlineEditor::m_title

private

Referenced by do_cancel(), do_commit(), open(), refuse(), and render().

request_frame

std::function<void()> Slic3r::GUI::SketchInlineEditor::request_frame

Referenced by render().

---

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

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