Console input keeps keyboard focus

ChangeLog.md

 ## OpenRaider (0.1.3) xythobuz <xythobuz@xythobuz.de>
 
     [ 20140930 ]
-    * Updated imgui to version 1.13
+    * Updated imgui to version 1.14 wip
+    * Console input keeps keyboard focus after command input
 
     [ 20140920 ]
     * Updated imgui (fix for resource leak)

include/Console.h

     const static int bufferLength = 256;
     static char buffer[bufferLength];
     static bool scrollToBottom;
+    static bool focusInput;
     static unsigned long lastLogLength;
 };
 

src/Console.cpp

 
 char Console::buffer[bufferLength] = "";
 bool Console::scrollToBottom = false;
+bool Console::focusInput = false;
 unsigned long Console::lastLogLength = 0;
 
 void Console::display() {
         }
         ImGui::EndChild();
 
+        if (focusInput) {
+            ImGui::SetKeyboardFocusHere();
+            focusInput = false;
+        }
+
         if (ImGui::InputText("Command", buffer, bufferLength,
                     ImGuiInputTextFlags_AutoSelectAll | ImGuiInputTextFlags_EnterReturnsTrue)) {
             getLog() << "> " << buffer << Log::endl;
             }
             buffer[0] = '\0';
             scrollToBottom = true;
+            focusInput = true;
         }
     }
     ImGui::End();

src/deps/imgui/imgui.cpp

-// ImGui library v1.13
+// ImGui library v1.14 wip
 // See ImGui::ShowTestWindow() for sample code.
 // Read 'Programmer guide' below for notes on how to setup ImGui in your codebase.
 // Get latest version at https://github.com/ocornut/imgui
  - filters: set a current filter that tree node can automatically query to hide themselves
  - filters: handle wildcards (with implicit leading/trailing *), regexps
  - shortcuts: add a shortcut api, e.g. parse "&Save" and/or "Save (CTRL+S)", pass in to widgets or provide simple ways to use (button=activate, input=focus)
- - input: keyboard: full keyboard navigation and focus.
+ ! keyboard: tooltip & combo boxes are messing up / not honoring keyboard tabbing
+ - keyboard: full keyboard navigation and focus.
  - input: support trackpad style scrolling & slider edit.
+ - tooltip: move to fit within screen (e.g. when mouse cursor is right of the screen).
  - misc: not thread-safe
  - misc: double-clicking on title bar to minimize isn't consistent, perhaps move to single-click on left-most collapse icon?
- - style editor: add a button to print C code.
+ - style editor: add a button to output C code.
  - optimisation/render: use indexed rendering
  - optimisation/render: move clip-rect to vertex data? would allow merging all commands
  - optimisation/render: merge command-lists with same clip-rect into one even if they aren't sequential? (as long as in-between clip rectangle don't overlap)?
     float                   ItemWidthDefault;
     ImGuiStorage            StateStorage;
     float                   FontWindowScale;                    // Scale multipler per-window
-
-    int                     FocusIdxCounter;                    // Start at -1 and increase as assigned via FocusItemRegister()
-    int                     FocusIdxRequestCurrent;             // Item being requested for focus, rely on layout to be stable between the frame pressing TAB and the next frame
-    int                     FocusIdxRequestNext;                // Item being requested for focus, for next update
-
     ImDrawList*             DrawList;
 
+    // Focus
+    int                     FocusIdxAllCounter;                 // Start at -1 and increase as assigned via FocusItemRegister()
+    int                     FocusIdxTabCounter;                 // (same, but only count widgets which you can Tab through)
+    int                     FocusIdxAllRequestCurrent;          // Item being requested for focus
+    int                     FocusIdxTabRequestCurrent;          // Tab-able item being requested for focus
+    int                     FocusIdxAllRequestNext;             // Item being requested for focus, for next update (relies on layout to be stable between the frame pressing TAB and the next frame)
+    int                     FocusIdxTabRequestNext;             // "
+
 public:
     ImGuiWindow(const char* name, ImVec2 default_pos, ImVec2 default_size);
     ~ImGuiWindow();
     ImGuiID     GetID(const void* ptr);
 
     void        AddToRenderList();
-    bool        FocusItemRegister(bool is_active, int* out_idx = NULL); // Return TRUE if focus is requested
+    bool        FocusItemRegister(bool is_active);      // Return true if focus is requested
     void        FocusItemUnregister();
 
     ImGuiAabb   Aabb() const                            { return ImGuiAabb(Pos, Pos+Size); }
     if (ImLength(Size) < 0.001f)
         AutoFitFrames = 3;
 
-    FocusIdxCounter = -1;
-    FocusIdxRequestCurrent = IM_INT_MAX;
-    FocusIdxRequestNext = IM_INT_MAX;
-
     DrawList = (ImDrawList*)ImGui::MemAlloc(sizeof(ImDrawList));
     new(DrawList) ImDrawList();
+
+    FocusIdxAllCounter = FocusIdxTabCounter = -1;
+    FocusIdxAllRequestCurrent = FocusIdxTabRequestCurrent = IM_INT_MAX;
+    FocusIdxAllRequestNext = FocusIdxTabRequestNext = IM_INT_MAX;
 }
 
 ImGuiWindow::~ImGuiWindow()
     return id;
 }
 
-bool ImGuiWindow::FocusItemRegister(bool is_active, int* out_idx)
+bool ImGuiWindow::FocusItemRegister(bool is_active)
 {
-    FocusIdxCounter++;
-    if (out_idx)
-        *out_idx = FocusIdxCounter;
-
     ImGuiState& g = GImGui;
     ImGuiWindow* window = GetCurrentWindow();
-    if (!window->DC.AllowKeyboardFocus.back())
-        return false;
 
-    // Process input at this point: TAB, Shift-TAB switch focus
-    if (FocusIdxRequestNext == IM_INT_MAX && is_active && ImGui::IsKeyPressedMap(ImGuiKey_Tab))
+    const bool allow_keyboard_focus = window->DC.AllowKeyboardFocus.back();
+    FocusIdxAllCounter++;
+    if (allow_keyboard_focus)
+        FocusIdxTabCounter++;
+
+    // Process keyboard input at this point: TAB, Shift-TAB switch focus
+    // We can always TAB out of a widget that doesn't allow tabbing in.
+    if (FocusIdxAllRequestNext == IM_INT_MAX && FocusIdxTabRequestNext == IM_INT_MAX && is_active && ImGui::IsKeyPressedMap(ImGuiKey_Tab))
     {
         // Modulo on index will be applied at the end of frame once we've got the total counter of items.
-        FocusIdxRequestNext = FocusIdxCounter + (g.IO.KeyShift ? -1 : +1);
+        FocusIdxTabRequestNext = FocusIdxTabCounter + (g.IO.KeyShift ? (allow_keyboard_focus ? -1 : 0) : +1);
     }
 
-    const bool focus_requested = (FocusIdxCounter == FocusIdxRequestCurrent);
-    return focus_requested;
+    if (FocusIdxAllCounter == FocusIdxAllRequestCurrent)
+        return true;
+
+    if (allow_keyboard_focus)
+        if (FocusIdxTabCounter == FocusIdxTabRequestCurrent)
+            return true;
+
+    return false;
 }
 
 void ImGuiWindow::FocusItemUnregister()
 {
-    FocusIdxCounter--;
+    FocusIdxAllCounter--;
+    FocusIdxTabCounter--;
 }
 
 void ImGuiWindow::AddToRenderList()
     // NB: Don't discard FocusedWindow if it isn't active, so that a window that go on/off programatically won't lose its keyboard focus.
     if (g.ActiveId == 0 && g.FocusedWindow != NULL && g.FocusedWindow->Visible && IsKeyPressedMap(ImGuiKey_Tab, false))
     {
-        g.FocusedWindow->FocusIdxRequestNext = 0;    
+        g.FocusedWindow->FocusIdxTabRequestNext = 0;
     }
 
     // Mark all windows as not visible
         else
             window->ItemWidthDefault = 200.0f;
 
-        // Prepare for keyboard focus requests
-        if (window->FocusIdxRequestNext == IM_INT_MAX || window->FocusIdxCounter == -1)
-        {
-            window->FocusIdxRequestCurrent = IM_INT_MAX;
-        }
+        // Prepare for focus requests
+        if (window->FocusIdxAllRequestNext == IM_INT_MAX || window->FocusIdxAllCounter == -1)
+            window->FocusIdxAllRequestCurrent = IM_INT_MAX;
         else
-        {
-            const int mod = window->FocusIdxCounter+1;
-            window->FocusIdxRequestCurrent = (window->FocusIdxRequestNext + mod) % mod;
-        }
-        window->FocusIdxCounter = -1;
-        window->FocusIdxRequestNext = IM_INT_MAX;
+            window->FocusIdxAllRequestCurrent = (window->FocusIdxAllRequestNext + (window->FocusIdxAllCounter+1)) % (window->FocusIdxAllCounter+1);
+        if (window->FocusIdxTabRequestNext == IM_INT_MAX || window->FocusIdxTabCounter == -1)
+            window->FocusIdxTabRequestCurrent = IM_INT_MAX;
+        else
+            window->FocusIdxTabRequestCurrent = (window->FocusIdxTabRequestNext + (window->FocusIdxTabCounter+1)) % (window->FocusIdxTabCounter+1);
+        window->FocusIdxAllCounter = window->FocusIdxTabCounter = -1;
+        window->FocusIdxAllRequestNext = window->FocusIdxTabRequestNext = IM_INT_MAX;
 
         ImGuiAabb title_bar_aabb = window->TitleBarAabb();
 
     window->NextScrollY = (window->DC.CursorPos.y + window->ScrollY) - (window->Pos.y + window->SizeFull.y * 0.5f) - (window->TitleBarHeight() + window->WindowPadding().y);
 }
 
+void SetKeyboardFocusHere(int offset)
+{
+    ImGuiWindow* window = GetCurrentWindow();
+    window->FocusIdxAllRequestNext = window->FocusIdxAllCounter + 1 + offset;
+    window->FocusIdxTabRequestNext = IM_INT_MAX;
+}
+
 void SetTreeStateStorage(ImGuiStorage* tree)
 {
     ImGuiWindow* window = GetCurrentWindow();
             ImGui::Text("Thanks for clicking me!");
         }
 
-        static bool check = true;
-        ImGui::Checkbox("checkbox", &check);
-
         if (ImGui::TreeNode("Tree"))
         {
             for (size_t i = 0; i < 5; i++)
             ImGui::TreePop();
         }
 
+        static bool check = true;
+        ImGui::Checkbox("checkbox", &check);
 
         static int e = 0;
         ImGui::RadioButton("radio a", &e, 0); ImGui::SameLine();
                 ImGui::BulletText("%s", lines[i]);
     }
 
+    if (ImGui::CollapsingHeader("Keyboard & Focus"))
+    {
+        if (ImGui::TreeNode("Tabbing"))
+        {
+            ImGui::Text("Use TAB/SHIFT+TAB to cycle thru keyboard editable fields.");
+            static char buf[32] = "dummy";
+            ImGui::InputText("1", buf, IM_ARRAYSIZE(buf));
+            ImGui::InputText("2", buf, IM_ARRAYSIZE(buf));
+            ImGui::InputText("3", buf, IM_ARRAYSIZE(buf));
+            ImGui::PushAllowKeyboardFocus(false);
+            ImGui::InputText("4 (tab skip)", buf, IM_ARRAYSIZE(buf));
+            //ImGui::SameLine(); ImGui::Text("(?)"); if (ImGui::IsHovered()) ImGui::SetTooltip("Use ImGui::PushAllowKeyboardFocus(bool)\nto disable tabbing through certain widgets.");
+            ImGui::PopAllowKeyboardFocus();
+            ImGui::InputText("5", buf, IM_ARRAYSIZE(buf));
+            ImGui::TreePop();
+        }
+
+        if (ImGui::TreeNode("Focus from code"))
+        {
+            bool focus_1 = ImGui::Button("Focus on 1"); ImGui::SameLine();
+            bool focus_2 = ImGui::Button("Focus on 2"); ImGui::SameLine();
+            bool focus_3 = ImGui::Button("Focus on 3");
+            static char buf[128] = "click on a button to set focus";
+            if (focus_1) ImGui::SetKeyboardFocusHere();
+            ImGui::InputText("1", buf, IM_ARRAYSIZE(buf));
+            if (focus_2) ImGui::SetKeyboardFocusHere();
+            ImGui::InputText("2", buf, IM_ARRAYSIZE(buf));
+            ImGui::PushAllowKeyboardFocus(false);
+            if (focus_3) ImGui::SetKeyboardFocusHere();
+            ImGui::InputText("3 (tab skip)", buf, IM_ARRAYSIZE(buf));
+            ImGui::PopAllowKeyboardFocus();
+            ImGui::TreePop();
+        }
+    }
+
     if (ImGui::CollapsingHeader("Long text"))
     {
         static ImGuiTextBuffer log;

src/deps/imgui/imgui.h

-// ImGui library v1.13
+// ImGui library v1.14 wip
 // See .cpp file for commentary.
 // See ImGui::ShowTestWindow() for sample code.
 // Read 'Programmer guide' in .cpp for notes on how to setup ImGui in your codebase.
     ImDrawList* GetWindowDrawList();                                                // get rendering command-list if you want to append your own draw primitives.
     void        SetWindowFontScale(float scale);                                    // per-window font scale. Adjust IO.FontBaseScale if you want to scale all windows together.
     void        SetScrollPosHere();                                                 // adjust scrolling position to center into the current cursor position.
+    void        SetKeyboardFocusHere(int offset = 0);                               // focus keyboard on the next widget. Use 'offset' to access sub components of a multiple component widget.
     void        SetTreeStateStorage(ImGuiStorage* tree);                            // replace tree state storage with our own (if you want to manipulate it yourself, typically clear subsection of it).
     ImGuiStorage* GetTreeStateStorage();
     void        PushItemWidth(float item_width);
     void        PopItemWidth();
     float       GetItemWidth();
-    void        PushAllowKeyboardFocus(bool v);
+    void        PushAllowKeyboardFocus(bool v);                                     // allow focusing using TAB/Shift-TAB, enabled by default but you can disable it for certain widgets.
     void        PopAllowKeyboardFocus();
     void        PushStyleColor(ImGuiCol idx, const ImVec4& col);
     void        PopStyleColor();
     ImVec2      FontTexUvForWhite;          // = (0.0f,0.0f)            // Font texture must have a white pixel at this UV coordinate. Adjust if you are using custom texture.
     float       FontBaseScale;              // = 1.0f                   // Base font scale, multiplied by the per-window font scale which you can adjust with SetFontScale()
     bool        FontAllowUserScaling;       // = false                  // Set to allow scaling text with CTRL+Wheel.
-	ImWchar     FontFallbackGlyph;          // = '?'                    // Replacement glyph is one isn't found.
+    ImWchar     FontFallbackGlyph;          // = '?'                    // Replacement glyph is one isn't found.
     float       PixelCenterOffset;          // = 0.0f                   // Try to set to 0.5f or 0.375f if rendering is blurry
 
     //------------------------------------------------------------------