Let Global shortcuts run while typing, except keys that edit text (#16558)

#16505 skipped every Global shortcut while ImGui had the keyboard, so
Ctrl+S, Ctrl+R and the others did nothing while the cursor was in the
text tool's box. Skip only the chords that edit text, and only while a
text field (a wx text entry, a spin control, a web view, or an active
ImGui InputText) has the focus. Skip every Global shortcut while an
ImGui modal is open on the focused canvas.

KeyChord::edits_text() defines the text-editing chords. The Global page
of the shortcuts dialog no longer says these shortcuts apply while
typing.

src/slic3r/GUI/ImGuiWrapper.cpp

@@ -62,6 +62,7 @@
 #include "Search.hpp"
 #include "BitmapCache.hpp"
 #include "GUI_App.hpp"
+#include "KeyChord.hpp"
 
 #include <nanosvg/nanosvg.h>
 #include <nanosvg/nanosvgrast.h>
@@ -2134,6 +2135,27 @@ bool ImGuiWrapper::want_any_input() const
     return io.WantCaptureMouse || io.WantCaptureKeyboard || io.WantTextInput;
 }
 
+bool ImGuiWrapper::text_input_active() const
+{
+    const ImGuiID id = ImGui::GetActiveID();
+    return id != 0 && ImGui::GetInputTextState(id) != nullptr;
+}
+
+bool ImGuiWrapper::modal_popup_open() const
+{
+    // A modal stays on the popup stack while its canvas is hidden, so it counts only if the last finished
+    // frame drew it, which NewFrame() moves from Active to WasActive.
+    const ImGuiWindow* modal = ImGui::GetTopMostPopupModal();
+    if (modal == nullptr)
+        return false;
+    return ImGui::GetCurrentContext()->WithinFrameScope ? modal->WasActive : modal->Active;
+}
+
+bool ImGuiWrapper::owns_key(const KeyChord& chord) const
+{
+    return modal_popup_open() || (chord.edits_text() && text_input_active());
+}
+
 ImFontAtlasCustomRect* ImGuiWrapper::GetTextureCustomRect(const wchar_t& tex_id)
 {
     auto item = m_custom_glyph_rects_ids.find(tex_id);

src/slic3r/GUI/ImGuiWrapper.hpp

@@ -35,6 +35,7 @@ struct ImRect;
 namespace Slic3r {
 namespace GUI {
 
+struct KeyChord;
 
 bool get_data_from_svg(const std::string &filename, unsigned int max_size_px, ThumbnailData &thumbnail_data);
 
@@ -219,6 +220,12 @@ public:
     bool want_keyboard() const;
     bool want_text_input() const;
     bool want_any_input() const;
+    // True while an ImGui InputText is active, without the one-frame lag of want_text_input().
+    bool text_input_active() const;
+    // True while an ImGui modal popup is on screen.
+    bool modal_popup_open() const;
+    // True for every key while a modal is open, and for text-editing keys while an InputText is active.
+    bool owns_key(const KeyChord& chord) const;
 
     // Optional inputs are used for set up value inside of an optional, with default value
     // 

src/slic3r/GUI/KBShortcutsDialog.cpp

@@ -173,7 +173,7 @@ void KBShortcutsDialog::fill_pages()
     using Section              = ShortcutSection;
 
     if (wxGetApp().is_editor()) {
-        page(_L("Global"), _L("Available anywhere in the window, even while typing in a text field."), ShortcutContext::Global, {
+        page(_L("Global"), _L("Available anywhere in the window."), ShortcutContext::Global, {
             fixed(Section::SpeedDial, { alt, "1-9, 0" }, L("Run favorite 1 to 10")),
             fixed(Section::SpeedDial, { ctrl, "B" }, L("Pin or unpin the selected action")),
             // wx cycles notebook pages on Ctrl+Tab, which is Cmd+Tab on macOS and never arrives there.
@@ -438,17 +438,16 @@ ShortcutCaptureDialog::ShortcutCaptureDialog(wxWindow* parent, Shortcut shortcut
     SetBackgroundColour(*wxWHITE);
     wxBoxSizer* sizer = new wxBoxSizer(wxVERTICAL);
 
-    // A Global shortcut also runs while a text field has the focus, so its hint names the keys it can use.
+    // A Global shortcut runs before the focused control gets the key, so its hint names the keys it can use.
     const bool     global = (shortcut_info(shortcut).contexts & context_bit(ShortcutContext::Global)) != 0;
     const wxString advice = global_key_advice();
-    const wxString typing = _L("Global shortcuts also apply while typing.");
     const wxString rule   = _L("A key that types a character cannot be a global shortcut.");
-    m_hint      = global ? typing + "\n" + advice : _L("Esc cancels, Enter confirms.");
+    m_hint      = global ? advice : _L("Esc cancels, Enter confirms.");
     m_rejection = rule + "\n" + advice;
 
     // Wide enough for each sentence on a line of its own where the translation allows, within limits.
     int width = FromDIP(450);
-    for (const wxString& sentence : { typing, rule, advice }) {
+    for (const wxString& sentence : { rule, advice }) {
         int extent = 0;
         GetTextExtent(sentence, &extent, nullptr, nullptr, nullptr, &wxGetApp().normal_font());
         width = std::max(width, extent);

src/slic3r/GUI/KeyChord.cpp

@@ -187,6 +187,40 @@ bool KeyChord::is_menu_accelerator() const
     return valid() && ((modifiers & (wxMOD_CONTROL | wxMOD_ALT | wxMOD_RAW_CONTROL)) != 0 || (!is_printable(key) && key != WXK_SPACE));
 }
 
+bool KeyChord::edits_text() const
+{
+    if (!valid())
+        return false;
+    if (!is_menu_accelerator())
+        return true;
+    const int mods = modifiers & ~wxMOD_SHIFT;
+    switch (key) {
+    case WXK_LEFT: case WXK_RIGHT: case WXK_UP: case WXK_DOWN:
+    case WXK_HOME: case WXK_END: case WXK_BACK: case WXK_DELETE:
+#ifdef __APPLE__
+        return mods == wxMOD_NONE || mods == wxMOD_CONTROL || mods == wxMOD_ALT; // Option moves by word
+#else
+        return mods == wxMOD_NONE || mods == wxMOD_CONTROL;
+#endif
+    case WXK_INSERT:
+        return mods == wxMOD_NONE || mods == wxMOD_CONTROL;
+    case WXK_RETURN: case WXK_TAB: case WXK_ESCAPE: case WXK_PAGEUP: case WXK_PAGEDOWN:
+        return mods == wxMOD_NONE;
+    default:
+        break;
+    }
+    if (!is_printable(key))
+        return false;
+#ifdef __APPLE__
+    if (mods == wxMOD_ALT || mods == wxMOD_RAW_CONTROL)
+        return true; // Option types a character, Control runs the Cocoa text key bindings
+#else
+    if (mods == (wxMOD_CONTROL | wxMOD_ALT))
+        return true; // AltGr types a character
+#endif
+    return mods == wxMOD_CONTROL && (key == 'A' || key == 'C' || key == 'V' || key == 'X' || key == 'Y' || key == 'Z');
+}
+
 // Only a chord the desktop acts on while still delivering it to the app belongs here.
 bool KeyChord::is_system_shortcut() const
 {

src/slic3r/GUI/KeyChord.hpp

@@ -35,6 +35,9 @@ struct KeyChord
     // True when Ctrl or Alt is held or the key is non-printable, the chords a menu can own without
     // swallowing typing in text fields.
     bool is_menu_accelerator() const;
+    // True for a chord a focused text field acts on: typing a character (AltGr and macOS Option
+    // characters included), moving the caret, selecting, deleting, or the clipboard and undo chords.
+    bool edits_text() const;
     // True for a chord the desktop acts on although the app receives it, so a binding would
     // take it from the system.
     bool is_system_shortcut() const;

src/slic3r/GUI/MainFrame.cpp

@@ -50,6 +50,7 @@
 #include <wx/panel.h>
 #include <wx/settings.h>
 #include <wx/textentry.h>
+#include <wx/spinctrl.h>
 #include <wx/notebook.h>
 #include <wx/listbook.h>
 #include <wx/simplebook.h>
@@ -107,6 +108,8 @@
 #include "../Utils/PrintHost.hpp"
 
 #include "GUI_App.hpp"
+#include "ImGuiWrapper.hpp"
+#include "OpenGLManager.hpp"
 #include "Shortcuts.hpp"
 #include "UnsavedChangesDialog.hpp"
 #include "PublishSettingsDialog.hpp"
@@ -184,18 +187,31 @@ enum class ERescaleTarget
 
 namespace {
 
+bool focus_is_text_field(wxWindow* focus)
+{
+    if (dynamic_cast<wxTextEntryBase*>(focus) || dynamic_cast<wxWebView*>(focus))
+        return true; // a web page can have its own text fields
+    if (dynamic_cast<wxSpinCtrl*>(focus) || dynamic_cast<wxSpinCtrlDouble*>(focus))
+        return true; // the native Windows spin control is not a wxTextEntry
+    return false;
+}
+
+// Only a scene canvas draws ImGui, and a hidden one can keep the wx focus after a tab switch.
+const ImGuiWrapper* focused_canvas_imgui(wxWindow* focus)
+{
+    if (!OpenGLManager::is_scene_canvas(focus) || !focus->IsShownOnScreen())
+        return nullptr;
+    return wxGetApp().imgui();
+}
+
 // Space opens the speed dial, but it is the activation key for buttons, checkboxes and other
-// controls. CHAR_HOOK runs before the focused child, so only take Space when the focused window has
-// no keyboard-activation meaning of its own. Canvases (GLCanvas3D) and panels are not controls and
-// fall through to "open"; the Notebook itself does too, so Space still opens the dial on any page.
+// controls, so only take Space when the focused window has no keyboard-activation meaning of its
+// own. Canvases (GLCanvas3D) and panels are not controls and fall through to "open"; the Notebook
+// itself does too, so Space still opens the dial on any page.
 bool focus_keeps_space(wxWindow* focus)
 {
     if (!focus)
         return false;
-    if (dynamic_cast<wxTextEntryBase*>(focus))
-        return true; // typing a space into a text field
-    if (dynamic_cast<wxWebView*>(focus))
-        return true; // web content scrolls and hosts its own text fields
     if (dynamic_cast<::Button*>(focus))
         return true; // custom button: Space clicks it (it is a wxWindow, not a wxControl)
     if (dynamic_cast<StaticBox*>(focus))
@@ -816,16 +832,12 @@ DPIFrame(NULL, wxID_ANY, "", wxDefaultPosition, wxDefaultSize, BORDERLESS_FRAME_
 
 bool MainFrame::handle_global_shortcut(const KeyChord& chord)
 {
-    // ImGui draws its text fields (the text tool's box, a sketch value field) on the GL canvas, so
-    // while one of them is typed into the focused wx window is that canvas or an in-canvas frame:
-    // neither is a wxControl, so focus_keeps_space() cannot see it and CHAR_HOOK takes the chord
-    // here first -- Space opened the Speed Dial, Ctrl+P the Preferences, and the field never saw
-    // the key. ImGui raises WantCaptureKeyboard while one of its items owns the keyboard, so leave
-    // the key to it then. A focused wxControl (text field, list, web view) is untouched: those
-    // keep their own keys, and ImGui's flag can outlive the focus moving to one of them.
+    // CHAR_HOOK runs before the focused window, so leave text-editing keys to a focused text field and
+    // the keys ImGui owns to the focused canvas.
     wxWindow* const focus = wxWindow::FindFocus();
-    ImGuiWrapper* const imgui = wxGetApp().imgui();
-    if (focus != nullptr && imgui != nullptr && imgui->want_keyboard() && dynamic_cast<wxControl*>(focus) == nullptr)
+    if (chord.edits_text() && focus_is_text_field(focus))
+        return false;
+    if (const ImGuiWrapper* imgui = focused_canvas_imgui(focus); imgui != nullptr && imgui->owns_key(chord))
         return false;
 
     const std::optional<Shortcut> shortcut = wxGetApp().shortcuts().lookup(ShortcutContext::Global, chord);

src/slic3r/GUI/OpenGLManager.cpp

@@ -427,6 +427,8 @@ wxGLContext* OpenGLManager::init_glcontext(wxGLCanvas& canvas, const std::pair<i
     return m_context;
 }
 
+static const char* const SCENE_CANVAS_NAME = "OrcaSceneCanvas";
+
 wxGLCanvas* OpenGLManager::create_wxglcanvas(wxWindow& parent)
 {
     int antialiasing_samples = 4;
@@ -470,12 +472,17 @@ wxGLCanvas* OpenGLManager::create_wxglcanvas(wxWindow& parent)
         attribList[samples_value_idx] = 0;
     }
 
-    wxGLCanvas* canvas = new wxGLCanvas(&parent, wxID_ANY, attribList, wxDefaultPosition, wxDefaultSize, wxWANTS_CHARS);
+    wxGLCanvas* canvas = new wxGLCanvas(&parent, wxID_ANY, attribList, wxDefaultPosition, wxDefaultSize, wxWANTS_CHARS, SCENE_CANVAS_NAME);
     // The GL canvas paints its entire surface, so background erasing is unnecessary.
     canvas->SetBackgroundStyle(wxBG_STYLE_PAINT);
     return canvas;
 }
 
+bool OpenGLManager::is_scene_canvas(const wxWindow* window)
+{
+    return window != nullptr && window->GetName() == SCENE_CANVAS_NAME;
+}
+
 void OpenGLManager::detect_multisample(int* attribList)
 {
     int wxVersion = wxMAJOR_VERSION * 10000 + wxMINOR_VERSION * 100 + wxRELEASE_NUMBER;

src/slic3r/GUI/OpenGLManager.hpp

@@ -101,6 +101,8 @@ public:
     static bool are_framebuffers_supported() { return (s_framebuffers_type != EFramebufferType::Unknown); }
     static EFramebufferType get_framebuffers_type() { return s_framebuffers_type; }
     static wxGLCanvas* create_wxglcanvas(wxWindow& parent);
+    // True for a canvas made by create_wxglcanvas(), the kind a GLCanvas3D draws its scene and ImGui into.
+    static bool is_scene_canvas(const wxWindow* window);
     static const GLInfo& get_gl_info() { return s_gl_info; }
     static bool force_power_of_two_textures() { return s_force_power_of_two_textures; }