[LLDB][GUI] Refactor form drawing using subsurfaces

[OmarEmaraDev]

Summary

This patch adds a new method SubSurface to the Surface class. The method
returns another surface that is a subset of this surface. This is
important to further abstract away drawing from the ncurses objects. For
instance, fields could previously be drawn on subpads only but can now
be drawn on any surface. This is needed to create the file search
dialogs and similar functionalities.

There is an opportunity to refactor window drawing in general using
surfaces, but we shall consider this separately later.

[jasonmolenda]

Am I the only one seeing a compiler error with this patch?

if (is_pad(m_window))

is_pad isn't defined anywhere?

[jasonmolenda]

I reverted this commit in 4d3d182c1dcb99ddcce7d077060d87111cb8dbfa to fix the build for now; I'm not sure where is_pad() is intended to come from.

[OmarEmaraDev]

@jasonmolenda is_pad is defined by ncurses. According to the man page, it is an extension that is not supported on Version 7, BSD or System V implementations., but that shouldn't be a problem as far as I know. Can you maybe check the ncurses header and see if it is there?

[OmarEmaraDev]

is_pad was added in 2009 in ncurses 5.7 - patch 20090906. So it is sufficiently old to be used, is it not?

[jasonmolenda]

In D107182#2930541, @OmarEmaraDev wrote:

is_pad was added in 2009 in ncurses 5.7 - patch 20090906. So it is sufficiently old to be used, is it not?

Thanks Omar, I didn't know that. I was building on macOS 11.5.1 (current newest release version). Looking at our curses.h, it looks like we have a slightly-too-old version of 5.7:

#define NCURSES_VERSION_MAJOR 5
#define NCURSES_VERSION_MINOR 7
#define NCURSES_VERSION_PATCH 20081102

is_pad isn't in the header or in the libcurses solib. And our next major version, macOS 12, is using the same version. :(

[OmarEmaraDev]

@jasonmolenda Okay, I will just reimplement the patch without is_pad somehow.

[jasonmolenda]

In D107182#2930666, @OmarEmaraDev wrote:

@jasonmolenda Okay, I will just reimplement the patch without is_pad somehow.

Thanks! Sorry it's so very old. :(

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>

 class Surface {
 public:
   Surface() : m_window(nullptr) {}
 
   WINDOW *get() { return m_window; }
 
   operator WINDOW *() { return m_window; }
 
+  Surface SubSurface(Rect bounds) {
+    Surface subSurface;
+    if (is_pad(m_window))
+      subSurface.m_window =
+          ::subpad(m_window, bounds.size.height, bounds.size.width,
+                   bounds.origin.y, bounds.origin.x);
+    else
+      subSurface.m_window =
+          ::derwin(m_window, bounds.size.height, bounds.size.width,
+                   bounds.origin.y, bounds.origin.x);
+    return subSurface;
+  }
+
   // Copy a region of the surface to another surface.
   void CopyToSurface(Surface &target, Point source_origin, Point target_origin,
                      Size size) {
     ::copywin(m_window, target.get(), source_origin.y, source_origin.x,
               target_origin.y, target_origin.x,
               target_origin.y + size.height - 1,
               target_origin.x + size.width - 1, false);
   }
public:
   // element then add the offset of the element in the field.
   virtual ScrollContext FieldDelegateGetScrollContext() {
     return ScrollContext(0, FieldDelegateGetHeight() - 1);
   }
 
   // Draw the field in the given subpad surface. The surface have a height that
   // is equal to the height returned by FieldDelegateGetHeight(). If the field
   // is selected in the form window, then is_selected will be true.
-  virtual void FieldDelegateDraw(SubPad &surface, bool is_selected) = 0;
+  virtual void FieldDelegateDraw(Surface &surface, bool is_selected) = 0;
 
   // Handle the key that wasn't handled by the form window or a container field.
   virtual HandleCharResult FieldDelegateHandleChar(int key) {
     return eKeyNotHandled;
   }
 
   // This is executed once the user exists the field, that is, once the user
   // navigates to the next or the previous field. This is particularly useful to
int FieldDelegateGetHeight() override {
     return height;
   }
 
   // Get the cursor X position in the surface coordinate.
   int GetCursorXPosition() { return m_cursor_position - m_first_visibile_char; }
 
   int GetContentLength() { return m_content.length(); }
 
-  void DrawContent(SubPad &surface, bool is_selected) {
+  void DrawContent(Surface &surface, bool is_selected) {
     surface.MoveCursor(0, 0);
     const char *text = m_content.c_str() + m_first_visibile_char;
     surface.PutCString(text, surface.GetWidth());
     m_last_drawn_content_width = surface.GetWidth();
 
     // Highlight the cursor.
     surface.MoveCursor(GetCursorXPosition(), 0);
     if (is_selected)
       surface.AttributeOn(A_REVERSE);
     if (m_cursor_position == GetContentLength())
       // Cursor is past the last character. Highlight an empty space.
       surface.PutChar(' ');
     else
       surface.PutChar(m_content[m_cursor_position]);
     if (is_selected)
       surface.AttributeOff(A_REVERSE);
   }
 
-  void DrawField(SubPad &surface, bool is_selected) {
+  void DrawField(Surface &surface, bool is_selected) {
     surface.TitledBox(m_label.c_str());
 
     Rect content_bounds = surface.GetFrame();
     content_bounds.Inset(1, 1);
-    SubPad content_surface = SubPad(surface, content_bounds);
+    Surface content_surface = surface.SubSurface(content_bounds);
 
     DrawContent(content_surface, is_selected);
   }
 
-  void DrawError(SubPad &surface) {
+  void DrawError(Surface &surface) {
     if (!FieldDelegateHasError())
       return;
     surface.MoveCursor(0, 0);
     surface.AttributeOn(COLOR_PAIR(RedOnBlack));
     surface.PutChar(ACS_DIAMOND);
     surface.PutChar(' ');
     surface.PutCStringTruncated(1, GetError().c_str());
     surface.AttributeOff(COLOR_PAIR(RedOnBlack));
   }
 
-  void FieldDelegateDraw(SubPad &surface, bool is_selected) override {
+  void FieldDelegateDraw(Surface &surface, bool is_selected) override {
     Rect frame = surface.GetFrame();
     Rect field_bounds, error_bounds;
     frame.HorizontalSplit(GetFieldHeight(), field_bounds, error_bounds);
-    SubPad field_surface = SubPad(surface, field_bounds);
-    SubPad error_surface = SubPad(surface, error_bounds);
+    Surface field_surface = surface.SubSurface(field_bounds);
+    Surface error_surface = surface.SubSurface(error_bounds);
 
     DrawField(field_surface, is_selected);
     DrawError(error_surface);
   }
 
   // The cursor is allowed to move one character past the string.
   // m_cursor_position is in range [0, GetContentLength()].
   void MoveCursorRight() {
public:
 
   // Boolean fields are drawn as checkboxes.
   //
   // [X] Label  or [ ] Label
 
   // Boolean fields are have a single line.
   int FieldDelegateGetHeight() override { return 1; }
 
-  void FieldDelegateDraw(SubPad &surface, bool is_selected) override {
+  void FieldDelegateDraw(Surface &surface, bool is_selected) override {
     surface.MoveCursor(0, 0);
     surface.PutChar('[');
     if (is_selected)
       surface.AttributeOn(A_REVERSE);
     surface.PutChar(m_content ? ACS_DIAMOND : ' ');
     if (is_selected)
       surface.AttributeOff(A_REVERSE);
     surface.PutChar(']');
public:
   int GetNumberOfChoices() { return m_choices.size(); }
 
   // Get the index of the last visible choice.
   int GetLastVisibleChoice() {
     int index = m_first_visibile_choice + m_number_of_visible_choices;
     return std::min(index, GetNumberOfChoices()) - 1;
   }
 
-  void DrawContent(SubPad &surface, bool is_selected) {
+  void DrawContent(Surface &surface, bool is_selected) {
     int choices_to_draw = GetLastVisibleChoice() - m_first_visibile_choice + 1;
     for (int i = 0; i < choices_to_draw; i++) {
       surface.MoveCursor(0, i);
       int current_choice = m_first_visibile_choice + i;
       const char *text = m_choices[current_choice].c_str();
       bool highlight = is_selected && current_choice == m_choice;
       if (highlight)
         surface.AttributeOn(A_REVERSE);
       surface.PutChar(current_choice == m_choice ? ACS_DIAMOND : ' ');
       surface.PutCString(text);
       if (highlight)
         surface.AttributeOff(A_REVERSE);
     }
   }
 
-  void FieldDelegateDraw(SubPad &surface, bool is_selected) override {
+  void FieldDelegateDraw(Surface &surface, bool is_selected) override {
     UpdateScrolling();
 
     surface.TitledBox(m_label.c_str());
 
     Rect content_bounds = surface.GetFrame();
     content_bounds.Inset(1, 1);
-    SubPad content_surface = SubPad(surface, content_bounds);
+    Surface content_surface = surface.SubSurface(content_bounds);
 
     DrawContent(content_surface, is_selected);
   }
 
   void SelectPrevious() {
     if (m_choice > 0)
       m_choice--;
   }
ScrollContext FieldDelegateGetScrollContext() override {
     // If the scroll context is touching the new button, include it as well as
     // the bottom border in the context.
     if (context.end == height - 3)
       context.end += 2;
 
     return context;
   }
 
-  void DrawRemoveButton(SubPad &surface, int highlight) {
+  void DrawRemoveButton(Surface &surface, int highlight) {
     surface.MoveCursor(1, surface.GetHeight() / 2);
     if (highlight)
       surface.AttributeOn(A_REVERSE);
     surface.PutCString("[Remove]");
     if (highlight)
       surface.AttributeOff(A_REVERSE);
   }
 
-  void DrawFields(SubPad &surface, bool is_selected) {
+  void DrawFields(Surface &surface, bool is_selected) {
     int line = 0;
     int width = surface.GetWidth();
     for (int i = 0; i < GetNumberOfFields(); i++) {
       int height = m_fields[i].FieldDelegateGetHeight();
       Rect bounds = Rect(Point(0, line), Size(width, height));
       Rect field_bounds, remove_button_bounds;
       bounds.VerticalSplit(bounds.size.width - sizeof(" [Remove]"),
                            field_bounds, remove_button_bounds);
-      SubPad field_surface = SubPad(surface, field_bounds);
-      SubPad remove_button_surface = SubPad(surface, remove_button_bounds);
+      Surface field_surface = surface.SubSurface(field_bounds);
+      Surface remove_button_surface = surface.SubSurface(remove_button_bounds);
 
       bool is_element_selected = m_selection_index == i && is_selected;
       bool is_field_selected =
           is_element_selected && m_selection_type == SelectionType::Field;
       bool is_remove_button_selected =
           is_element_selected &&
           m_selection_type == SelectionType::RemoveButton;
       m_fields[i].FieldDelegateDraw(field_surface, is_field_selected);
       DrawRemoveButton(remove_button_surface, is_remove_button_selected);
 
       line += height;
     }
   }
 
-  void DrawNewButton(SubPad &surface, bool is_selected) {
+  void DrawNewButton(Surface &surface, bool is_selected) {
     const char *button_text = "[New]";
     int x = (surface.GetWidth() - sizeof(button_text) - 1) / 2;
     surface.MoveCursor(x, 0);
     bool highlight =
         is_selected && m_selection_type == SelectionType::NewButton;
     if (highlight)
       surface.AttributeOn(A_REVERSE);
     surface.PutCString(button_text);
     if (highlight)
       surface.AttributeOff(A_REVERSE);
   }
 
-  void FieldDelegateDraw(SubPad &surface, bool is_selected) override {
+  void FieldDelegateDraw(Surface &surface, bool is_selected) override {
     surface.TitledBox(m_label.c_str());
 
     Rect content_bounds = surface.GetFrame();
     content_bounds.Inset(1, 1);
     Rect fields_bounds, new_button_bounds;
     content_bounds.HorizontalSplit(content_bounds.size.height - 1,
                                    fields_bounds, new_button_bounds);
-    SubPad fields_surface = SubPad(surface, fields_bounds);
-    SubPad new_button_surface = SubPad(surface, new_button_bounds);
+    Surface fields_surface = surface.SubSurface(fields_bounds);
+    Surface new_button_surface = surface.SubSurface(new_button_bounds);
 
     DrawFields(fields_surface, is_selected);
     DrawNewButton(new_button_surface, is_selected);
   }
 
   void AddNewField() {
     m_fields.push_back(m_default_field);
     m_selection_index = GetNumberOfFields() - 1;
public:
 
   // The mapping field has a height that is equal to the maximum height between
   // the key and value fields.
   int FieldDelegateGetHeight() override {
     return std::max(m_key_field.FieldDelegateGetHeight(),
                     m_value_field.FieldDelegateGetHeight());
   }
 
-  void DrawArrow(SubPad &surface) {
+  void DrawArrow(Surface &surface) {
     surface.MoveCursor(0, 1);
     surface.PutChar(ACS_RARROW);
   }
 
-  void FieldDelegateDraw(SubPad &surface, bool is_selected) override {
+  void FieldDelegateDraw(Surface &surface, bool is_selected) override {
     Rect bounds = surface.GetFrame();
     Rect key_field_bounds, arrow_and_value_field_bounds;
     bounds.VerticalSplit(bounds.size.width / 2, key_field_bounds,
                          arrow_and_value_field_bounds);
     Rect arrow_bounds, value_field_bounds;
     arrow_and_value_field_bounds.VerticalSplit(1, arrow_bounds,
                                                value_field_bounds);
 
-    SubPad key_field_surface = SubPad(surface, key_field_bounds);
-    SubPad arrow_surface = SubPad(surface, arrow_bounds);
-    SubPad value_field_surface = SubPad(surface, value_field_bounds);
+    Surface key_field_surface = surface.SubSurface(key_field_bounds);
+    Surface arrow_surface = surface.SubSurface(arrow_bounds);
+    Surface value_field_surface = surface.SubSurface(value_field_bounds);
 
     bool key_is_selected =
         m_selection_type == SelectionType::Key && is_selected;
     m_key_field.FieldDelegateDraw(key_field_surface, key_is_selected);
     DrawArrow(arrow_surface);
     bool value_is_selected =
         m_selection_type == SelectionType::Value && is_selected;
     m_value_field.FieldDelegateDraw(value_field_surface, value_is_selected);

 public:
   FormAction(const char *label, std::function<void(Window &)> action)
       : m_action(action) {
     if (label)
       m_label = label;
   }
 
   // Draw a centered [Label].
-  void Draw(SubPad &surface, bool is_selected) {
+  void Draw(Surface &surface, bool is_selected) {
     int x = (surface.GetWidth() - m_label.length()) / 2;
     surface.MoveCursor(x, 0);
     if (is_selected)
       surface.AttributeOn(A_REVERSE);
     surface.PutChar('[');
     surface.PutCString(m_label.c_str());
     surface.PutChar(']');
     if (is_selected)
ScrollContext GetScrollContext() {
     // If the context is touching the error, include the error in the context as
     // well.
     if (context.start == GetErrorHeight())
       context.start = 0;
 
     return context;
   }
 
-  void UpdateScrolling(DerivedWindow &surface) {
+  void UpdateScrolling(Surface &surface) {
     ScrollContext context = GetScrollContext();
     int content_height = GetContentHeight();
     int surface_height = surface.GetHeight();
     int visible_height = std::min(content_height, surface_height);
     int last_visible_line = m_first_visible_line + visible_height - 1;
 
     // If the last visible line is bigger than the content, then it is invalid
     // and needs to be set to the last line in the content. This can happen when
     // a field has shrunk in height.
     if (last_visible_line > content_height - 1) {
       m_first_visible_line = content_height - visible_height;
     }
 
     if (context.start < m_first_visible_line) {
       m_first_visible_line = context.start;
       return;
     }
 
     if (context.end > last_visible_line) {
       m_first_visible_line = context.end - visible_height + 1;
     }
   }
 
-  void DrawError(SubPad &surface) {
+  void DrawError(Surface &surface) {
     if (!m_delegate_sp->HasError())
       return;
     surface.MoveCursor(0, 0);
     surface.AttributeOn(COLOR_PAIR(RedOnBlack));
     surface.PutChar(ACS_DIAMOND);
     surface.PutChar(' ');
     surface.PutCStringTruncated(1, m_delegate_sp->GetError().c_str());
     surface.AttributeOff(COLOR_PAIR(RedOnBlack));
 
     surface.MoveCursor(0, 1);
     surface.HorizontalLine(surface.GetWidth());
   }
 
-  void DrawFields(SubPad &surface) {
+  void DrawFields(Surface &surface) {
     int line = 0;
     int width = surface.GetWidth();
     bool a_field_is_selected = m_selection_type == SelectionType::Field;
     for (int i = 0; i < m_delegate_sp->GetNumberOfFields(); i++) {
       FieldDelegate *field = m_delegate_sp->GetField(i);
       if (!field->FieldDelegateIsVisible())
         continue;
       bool is_field_selected = a_field_is_selected && m_selection_index == i;
       int height = field->FieldDelegateGetHeight();
       Rect bounds = Rect(Point(0, line), Size(width, height));
-      SubPad field_surface = SubPad(surface, bounds);
+      Surface field_surface = surface.SubSurface(bounds);
       field->FieldDelegateDraw(field_surface, is_field_selected);
       line += height;
     }
   }
 
-  void DrawActions(SubPad &surface) {
+  void DrawActions(Surface &surface) {
     int number_of_actions = m_delegate_sp->GetNumberOfActions();
     int width = surface.GetWidth() / number_of_actions;
     bool an_action_is_selected = m_selection_type == SelectionType::Action;
     int x = 0;
     for (int i = 0; i < number_of_actions; i++) {
       bool is_action_selected = an_action_is_selected && m_selection_index == i;
       FormAction &action = m_delegate_sp->GetAction(i);
       Rect bounds = Rect(Point(x, 0), Size(width, 1));
-      SubPad action_surface = SubPad(surface, bounds);
+      Surface action_surface = surface.SubSurface(bounds);
       action.Draw(action_surface, is_action_selected);
       x += width;
     }
   }
 
-  void DrawElements(SubPad &surface) {
+  void DrawElements(Surface &surface) {
     Rect frame = surface.GetFrame();
     Rect fields_bounds, actions_bounds;
     frame.HorizontalSplit(surface.GetHeight() - GetActionsHeight(),
                           fields_bounds, actions_bounds);
-    SubPad fields_surface = SubPad(surface, fields_bounds);
-    SubPad actions_surface = SubPad(surface, actions_bounds);
+    Surface fields_surface = surface.SubSurface(fields_bounds);
+    Surface actions_surface = surface.SubSurface(actions_bounds);
 
     DrawFields(fields_surface);
     DrawActions(actions_surface);
   }
 
   // Contents are first drawn on a pad. Then a subset of that pad is copied to
   // the derived window starting at the first visible line. This essentially
   // provides scrolling functionality.
-  void DrawContent(DerivedWindow &surface) {
+  void DrawContent(Surface &surface) {
     UpdateScrolling(surface);
 
     int width = surface.GetWidth();
     int height = GetContentHeight();
     Pad pad = Pad(Size(width, height));
 
     Rect frame = pad.GetFrame();
     Rect error_bounds, elements_bounds;
     frame.HorizontalSplit(GetErrorHeight(), error_bounds, elements_bounds);
-    SubPad error_surface = SubPad(pad, error_bounds);
-    SubPad elements_surface = SubPad(pad, elements_bounds);
+    Surface error_surface = pad.SubSurface(error_bounds);
+    Surface elements_surface = pad.SubSurface(elements_bounds);
 
     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));
   }
 
   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");
 
     Rect content_bounds = window.GetFrame();
     content_bounds.Inset(2, 2);
-    DerivedWindow content_surface = DerivedWindow(window, content_bounds);
+    Surface content_surface = window.SubSurface(content_bounds);
 
     DrawContent(content_surface);
     return true;
   }
 
   void SkipNextHiddenFields() {
     while (true) {
       if (m_delegate_sp->GetField(m_selection_index)->FieldDelegateIsVisible())