[LLDB][GUI] Add submit form key combination

[OmarEmaraDev]

Summary

This patch adds a new key ALt+Enter key combination to form windows.
Once invoked, the first action is executed without having to navigate to
its button.

Field exit callbacks are now also invoked on validation to support this
aforementioned key combination.

One concern for this key combination is its potential use by the window
manager of the host. I am not sure if this will be a problem, but it is
worth putting in consideration.

[clayborg]

Just tried it out. Works nicely.

lldb/source/Core/IOHandlerCursesGUI.cpp

 //===-- IOHandlerCursesGUI.cpp --------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/IOHandlerCursesGUI.h"
 #include "lldb/Host/Config.h"
 
 #if LLDB_ENABLE_CURSES
 #if CURSES_HAVE_NCURSES_CURSES_H
 #include <ncurses/curses.h>
 #include <ncurses/panel.h>
 #else
 #include <curses.h>

 
 // we may want curses to be disabled for some builds for instance, windows
 #if LLDB_ENABLE_CURSES
 
 #define KEY_RETURN 10
 #define KEY_ESCAPE 27
 
 #define KEY_SHIFT_TAB (KEY_MAX + 1)
+#define KEY_ALT_ENTER (KEY_MAX + 2)
 
 namespace curses {
 class Menu;
 class MenuDelegate;
 class Window;
 class WindowDelegate;
 typedef std::shared_ptr<Menu> MenuSP;
 typedef std::shared_ptr<MenuDelegate> MenuDelegateSP;
public:
 
   void SetError(const char *error) { m_error = error; }
 
   // If all fields are valid, true is returned. Otherwise, an error message is
   // set and false is returned. This method is usually called at the start of an
   // action that requires valid fields.
   bool CheckFieldsValidity() {
     for (int i = 0; i < GetNumberOfFields(); i++) {
+      GetField(i)->FieldDelegateExitCallback();
       if (GetField(i)->FieldDelegateHasError()) {
         SetError("Some fields are invalid!");
         return false;
       }
     }
     return true;
   }
 
void DrawContent(Surface &surface) {
     DrawError(error_surface);
     DrawElements(elements_surface);
 
     int copy_height = std::min(surface.GetHeight(), pad.GetHeight());
     pad.CopyToSurface(surface, Point(0, m_first_visible_line), Point(),
                       Size(width, copy_height));
   }
 
+  void DrawSubmitHint(Surface &surface, bool is_active) {
+    surface.MoveCursor(2, surface.GetHeight() - 1);
+    if (is_active)
+      surface.AttributeOn(A_BOLD | COLOR_PAIR(BlackOnWhite));
+    surface.Printf("[Press Alt+Enter to %s]",
+                   m_delegate_sp->GetAction(0).GetLabel().c_str());
+    if (is_active)
+      surface.AttributeOff(A_BOLD | COLOR_PAIR(BlackOnWhite));
+  }
+
   bool WindowDelegateDraw(Window &window, bool force) override {
     m_delegate_sp->UpdateFieldsVisibility();
 
     window.Erase();
 
     window.DrawTitleBox(m_delegate_sp->GetName().c_str(),
-                        "Press Esc to cancel");
+                        "Press Esc to Cancel");
+    DrawSubmitHint(window, window.IsActive());
 
     Rect content_bounds = window.GetFrame();
     content_bounds.Inset(2, 2);
     Surface content_surface = window.SubSurface(content_bounds);
 
     DrawContent(content_surface);
     return true;
   }
if (m_selection_type == SelectionType::Field) {
       FieldDelegate *previous_field =
           m_delegate_sp->GetField(m_selection_index);
       previous_field->FieldDelegateSelectLastElement();
     }
 
     return eKeyHandled;
   }
 
-  void ExecuteAction(Window &window) {
-    FormAction &action = m_delegate_sp->GetAction(m_selection_index);
+  void ExecuteAction(Window &window, int index) {
+    FormAction &action = m_delegate_sp->GetAction(index);
     action.Execute(window);
     if (m_delegate_sp->HasError()) {
       m_first_visible_line = 0;
       m_selection_index = 0;
       m_selection_type = SelectionType::Field;
     }
   }
 
   HandleCharResult WindowDelegateHandleChar(Window &window, int key) override {
     switch (key) {
     case '\r':
     case '\n':
     case KEY_ENTER:
       if (m_selection_type == SelectionType::Action) {
-        ExecuteAction(window);
+        ExecuteAction(window, m_selection_index);
         return eKeyHandled;
       }
       break;
+    case KEY_ALT_ENTER:
+      ExecuteAction(window, 0);
+      return eKeyHandled;
     case '\t':
       return SelectNext(key);
     case KEY_SHIFT_TAB:
       return SelectPrevious(key);
     case KEY_ESCAPE:
       window.GetParent()->RemoveSubWindow(&window);
       return eKeyHandled;
     default:
if (!m_app_ap) {
     init_pair(15, COLOR_CYAN, COLOR_BLUE);
     init_pair(16, COLOR_WHITE, COLOR_BLUE);
     // These must match the order in the color indexes enum.
     init_pair(17, COLOR_BLACK, COLOR_WHITE);
     init_pair(18, COLOR_MAGENTA, COLOR_WHITE);
     static_assert(LastColorPairIndex == 18, "Color indexes do not match.");
 
     define_key("\033[Z", KEY_SHIFT_TAB);
+    define_key("\033\015", KEY_ALT_ENTER);
   }
 }
 
 void IOHandlerCursesGUI::Deactivate() { m_app_ap->Terminate(); }
 
 void IOHandlerCursesGUI::Run() {
   m_app_ap->Run(m_debugger);
   SetIsDone(true);