[lldb/IOHandlerCursesGUI] Make the menu bar clickable

[JDevlieghere]

Summary

Add mouse support to the IOHandlerCursesGUI and make it possible to select items in the top menu bar by clicking on them. This patch only makes the top level items clickable and does not (yet) make it possible to click on items in the submenu.

This patch is mostly me being curious about the IOHandlerCursesGUI and trying to understand how it works.

[labath]

Being curious is nice, but it would be even nicer if we figured out a way to test all of this stuff. Currently we have some very basic pexpect tests for this, but it's not clear how that will scale to more complex interactions (such as mouse clicking).

My idea for a test strategy (which is looking for someone to implement it) is to write (or resuse an existing -- pyte looks interesting) a simple "terminal emulator" in python. The idea is that this would process the raw escape sequences and produce an in-memory view of what the resulting screen should look like. Then we just connect the pexpect output to this terminal emulator.

This would allow us to write assertions based on that the virtual terminal view, so that we check *what* actually gets printed on the screen, and ignore the exact details about *how* it gets printed. (e.g. self.assertIn("Process (F3)", screen[0])...

(All this assumes that we're able to inject mouse clicks via pexpect, which I haven't checked whether it's possible, but I presume pexpect is low-level enough to be able to do something like that.)

[clayborg]

I wrote all this, so feel free to contact me directly with questions! It would be nice to pass the events along to the window or object for the mouse coordinates. See inlined comment and let me know what you think.

lldb/source/Core/IOHandlerCursesGUI.cpp

1085

It might be nice for this to be a bit more generic and be GetWindowForPosition(...). If we are going to enable mouse support, it would be nice to pass the mouse clicks to the windows and let them handle the clicks. Something like:

auto window = GetWindowForPosition(event.x, event.y);
if (window)
  result = window->HandleMouseButtonPressed(event);

The HandleMouseButton will return eKeyHandled if it handled the press. We might also allow other button presses to be passed along for right click and center clicks.
Then menu bars can handle the clicking. We might also want to pass

lldb/source/Core/IOHandlerCursesGUI.cpp

public:
   int GetKeyValue() const { return m_key_value; }
 
   std::string &GetName() { return m_name; }
 
   int GetDrawWidth() const {
     return m_max_submenu_name_length + m_max_submenu_key_name_length + 8;
   }
 
+  int GetTitleDrawWidth() const {
+    const int key_width = m_key_name.empty() ? 1 : m_key_name.size();
+    return m_name.size() + key_width + 2 /* padding */ + 1 /* space */ +
+           2 /* braces */;
+  }
+
+  int GetSubmenuForPosition(int x, int y);
+
   uint64_t GetIdentifier() const { return m_identifier; }
 
   void SetIdentifier(uint64_t identifier) { m_identifier = identifier; }
 
 protected:
   std::string m_name;
   std::string m_key_name;
   uint64_t m_identifier;
bool Menu::WindowDelegateDraw(Window &window, bool force) {
 
   default:
   case Menu::Type::Separator:
     break;
   }
   return true; // Drawing handled...
 }
 
+int Menu::GetSubmenuForPosition(int x, int y) {
+  if (y != 0)
+    return INT32_MAX;
+
+  int begin = 0;
+  int end = 0;
+  int i = 0;
+  for (const MenuSP &menu : m_submenus) {
+    begin = end + 1 /* separator */;
+    end = begin + menu->GetTitleDrawWidth();
+    if (x >= begin && x < end)
+      return i;
+    ++i;
+  }
+
+  return INT32_MAX;
+}
+
 HandleCharResult Menu::WindowDelegateHandleChar(Window &window, int key) {
   HandleCharResult result = eKeyNotHandled;
 
   Menus &submenus = GetSubmenus();
   const size_t num_submenus = submenus.size();
   const int selected_idx = GetSelectedSubmenuIndex();
+  MEVENT event;
   Menu::Type menu_type = GetType();
   if (menu_type == Menu::Type::Bar) {
     MenuSP run_menu_sp;
     switch (key) {
     case KEY_DOWN:
     case KEY_UP:
       // Show last menu or first menu
       if (selected_idx < static_cast<int>(num_submenus))
case KEY_LEFT:
         m_selected = num_submenus - 1;
       if (m_selected < static_cast<int>(num_submenus))
         run_menu_sp = submenus[m_selected];
       else if (!submenus.empty())
         run_menu_sp = submenus.front();
       result = eKeyHandled;
       break;
 
+    case KEY_MOUSE:
+      if (getmouse(&event) == OK) {
+        if (event.bstate & BUTTON1_PRESSED) {
+          int selected = GetSubmenuForPosition(event.x, event.y);
+          if (selected < static_cast<int>(num_submenus)) {
+            m_selected = selected;
+            run_menu_sp = submenus[m_selected];
+          }
+          result = eKeyHandled;
+        }
+      }
+      break;
+
     default:
       for (size_t i = 0; i < num_submenus; ++i) {
         if (submenus[i]->GetKeyValue() == key) {
           SetSelectedSubmenuIndex(i);
           run_menu_sp = submenus[i];
           result = eKeyHandled;
           break;
         }
void Run(Debugger &debugger) {
     // pass the keys down but then we need to translate all of the escape
     // sequences ourselves. So we resort to polling for input because we need
     // to receive async process events while in this loop.
 
     halfdelay(delay_in_tenths_of_a_second); // Poll using some number of tenths
                                             // of seconds seconds when calling
                                             // Window::GetChar()
 
+    // Enable mouse support.
+    keypad(stdscr, true);
+    mouseinterval(0);
+    mousemask(BUTTON1_PRESSED, NULL);
+
     ListenerSP listener_sp(
         Listener::MakeListener("lldb.IOHandler.curses.Application"));
     ConstString broadcaster_class_target(Target::GetStaticBroadcasterClass());
     ConstString broadcaster_class_process(Process::GetStaticBroadcasterClass());
     ConstString broadcaster_class_thread(Thread::GetStaticBroadcasterClass());
     debugger.EnableForwardEvents(listener_sp);
 
     bool update = true;