[LLDB][GUI] Add initial forms support

[OmarEmaraDev]

Summary

This patch adds initial support for forms for the LLDB GUI. The currently
supported form elements are Text fields, Integer fields, Boolean fields, Choices
fields, File fields, Directory fields, and List fields.

A form can be created by subclassing FormDelegate. In the constructor, field
factory methods can be used to add new fields, storing the returned pointer in a
member variable. One or more actions can be added using the AddAction method.
The method takes a function with an interface void(Window &). This function will
be executed whenever the user executes the action.

Example form definition:

class TestFormDelegate : public FormDelegate {
public:
  TestFormDelegate() {
    m_text_field = AddTextField("Text", "The big brown fox.");
    m_file_field = AddFileField("File", "/tmp/a");
    m_directory_field = AddDirectoryField("Directory", "/tmp/");
    m_integer_field = AddIntegerField("Number", 5);
    std::vector<std::string> choices;
    choices.push_back(std::string("Choice 1"));
    choices.push_back(std::string("Choice 2"));
    choices.push_back(std::string("Choice 3"));
    choices.push_back(std::string("Choice 4"));
    choices.push_back(std::string("Choice 5"));
    m_choices_field = AddChoicesField("Choices", 3, choices);
    m_bool_field = AddBooleanField("Boolean", true);
    TextFieldDelegate default_field =
        TextFieldDelegate("Text", "The big brown fox.");
    m_text_list_field = AddListField("Text List", default_field);

    AddAction("Submit", [this](Window &window) { Submit(window); });
  }

  void Submit(Window &window) { SetError("An example error."); }

protected:
  TextFieldDelegate *m_text_field;
  FileFieldDelegate *m_file_field;
  DirectoryFieldDelegate *m_directory_field;
  IntegerFieldDelegate *m_integer_field;
  BooleanFieldDelegate *m_bool_field;
  ChoicesFieldDelegate *m_choices_field;
  ListFieldDelegate<TextFieldDelegate> *m_text_list_field;
};

[OmarEmaraDev]

An example form:

class TestFormDelegate : public FormDelegate {
public:
  TestFormDelegate() {
    m_path_field = AddTextField("Path", 20, Point(4, 2), "/tmp/a.out");
    m_number_field = AddIntegerField("Number", 20, Point(4, 5), 5);
    m_bool_field = AddBooleanField("Boolean", Point(5, 8), true);
    std::vector<std::string> choices;
    choices.push_back(std::string("Choice 1"));
    choices.push_back(std::string("Choice 2"));
    choices.push_back(std::string("Choice 3"));
    choices.push_back(std::string("Choice 4"));
    choices.push_back(std::string("Choice 5"));
    m_choices_field = AddChoicesField("Choices", 20, 5, Point(30, 2), choices);
  }

  bool FormDelegateSubmit() override {
    std::string path = m_path_field->GetText();
    int number = m_number_field->GetInteger();
    bool boolean = m_bool_field->GetBoolean();

    // Do something with the data.

    if (everything_is_correct)
      return true;

    if (there_is_an_error) {
      m_has_error = true;
      m_error =
      std::string("An error occured! Check the validity of the inputs.");
      return false;
    }
  }

protected:
  TextFieldDelegate *m_path_field;
  IntegerFieldDelegate *m_number_field;
  BooleanFieldDelegate *m_bool_field;
  ChoicesFieldDelegate *m_choices_field;
};

[clayborg]

Looks very nice.

A few things to consider here, and I am open to everyone's opinion here, did you consider implementing each field as a Window? It seems that a lot of the window code is duplicated, DrawBox for one. I know we would need to make modifications to the Window class if this, but just something to think about. It might be more trouble that it is worth.

Another question I have is if we want a box around each field and do we want the user to be able to select the exact location of each item? Right now we can make a nice UI with almost window like fields, but I worry that if we have a lot of fields and they don't fit in the window, how complex it the scrolling code going to be? Another way would be to make a list of fields. And you add them in the order you want them to show up in the list. There could be no boxes around each field in this case and the window could look more like a list in this case. I will try and show with some ASCII art what I was thinking:

/--------------------------------------------------------------------\
| Path: /tmp/a.out                                                   |
| Number: 1234                                                       |
| Boolean: true                                                      |
| Choices: Choice 1                                                  |
|--------------------------------------------------------------------|
|                              [ SUBMIT ]                            |
\--------------------------------------------------------------------/

This might make it easier to implement scrolling if there are too many entries to fit on the screen.

Future things we can add would include:

• a field grouping field that would not take any input, but it would allow fields to be grouped into sections
• subclasses of the text field that allow for things like paths which might auto complete and allow only files or directories to be selected based on constructor args
• an array of a specific kind of fields, like for program arguments that would take a FieldDelegate and allow for a list to be created

lldb/source/Core/IOHandlerCursesGUI.cpp

433–439

move this below function below PutCStringTruncated so that PutCStringTruncated doesn't appear to be edited.

708

Do we need to use PutCStringTruncated here just in case?

931–933

"m_content(content):" will crash if content is NULL.

958

Does this need to be an integer? Can we return "size_t"?

1056

Return const reference to avoid copy. If use wants to copy it, they can assign to a local

1104

We could use ACS_DIAMOND or ACS_BULLET? Check it out and see how it looks?

1116

enter or return key as well? or is that saved for submit in the main window?

1438

The submit button?

[OmarEmaraDev]

did you consider implementing each field as a Window?

My first implementation was actually done completely with fields as sub windows.
However, two things deterred me from taking that approach.

• While sub-windows in ncurses are mostly sub-spaces with their own local coordinate system and cursor, which would be a good abstraction to use for fields, their implementation in the Window class seemed more involved than needed, with panels for drawing even. So I thought maybe they are not supposed to be used in that manner. I also though about introducing a type that is more lightweight and suitable for this kind of thing, but that didn't seem worth it at the moment. I will come back to this in a future patch though.
• Field construction doesn't have access to the possible parent window needed to create the sub-window, which means we will either have to pass the window around during construction or we will have to conditionally construct it the first window draw. Neither of those sounded like a good method to me.

The field drawing code used some special coordinate computation anyways, so
sub-spacing there was natural to do. Moreover, I don't think the duplicated code
with the Window is a lot, a non-border box drawing function is still useful to
have so I wouldn't think of it as a duplicate code.

how complex it the scrolling code going to be?

I will try to answer this question now to make it easier to decide what we need to
do. But I basically wanted full flexibility when it comes to drawing, with possibly
multiple row fields like the choices field and multi-column forms. The forms ncurses
library uses pages instead of scrolling to make this easier, so they would put the
most important fields in the first page and more fields in later pages. But I will let
you know what I think after I look into scrolling first.

lldb/source/Core/IOHandlerCursesGUI.cpp

958

The compiler kept throwing sign comparison warnings in expressions like m_cursor_position < m_content.length(), so I just casted to an integer. How should I properly handle this?

1116

Sure, we can do that. Enter is only handled if the button is selected.

1438

Yes.

[OmarEmaraDev]

• Remove PutCStringTruncatedWidth, use a character limit instead.
• Handle review.

[OmarEmaraDev]

lldb/source/Core/IOHandlerCursesGUI.cpp

1104

What do you think?

[OmarEmaraDev]

• Always scroll left on removing a character

[clayborg]

Lets try the diamond character for the boolean stuff unless anyone has any objections. Maybe handle a few more keys for the boolean field as suggested in the comments. This will be good to go after these changes!

lldb/source/Core/IOHandlerCursesGUI.cpp

960

It is fine to leave cast to int if this is causing compiler warnings. Many things are integers in the curses API.

1104

I like the diamond one personally. Looks nice and clean

1121

maybe handle '1' to set m_content to true and '0' to set to false? Could also handle 't' for true and 'f' for false?

[OmarEmaraDev]

• Add form pages.
• Handle review.

[clayborg]

Looks good!

[OmarEmaraDev]

@clayborg I tried implementing scrolling mechanisms as suggested. My first trial essentially defined a "visible area" rectangle which gets updated with every time the selection changes, then when it comes to drawing, each field checks if it is completely contained in the visible area and draws itself with an offset that we get from from the visible area origin. This worked, but fields that spans multiple columns can completely disappear leaving mostly no fields on the window, so it worked in most cases, but not all. My second trial was about drawing to an ncurses pad that is large enough to fit all contents, then the window is refreshed from that pad. This used manual ncurses calls because we don't support pads at the moment, so I scratched that for now. I think support for pads would be good for those kind of applications in the future. I plan to work on a proposal that would include support for pads and lightweight subwindows, I will detail that later.

I eventually opted to create "pages" for the forms. Basically, during form construction, if the number of fields is large and can't fit in the window, the user can call NewPage() to create a new page, all fields after that call gets added to the new page. As the user selects fields, the form can scroll to different pages. This is similar to the ncurses form scrolling functionality. Visual indicator for the current pages and the active page is added to the form if there is more than one page. I hope this solution is satisfactory.

[clayborg]

In D104395#2828065, @OmarEmaraDev wrote:

@clayborg I tried implementing scrolling mechanisms as suggested. My first trial essentially defined a "visible area" rectangle which gets updated with every time the selection changes, then when it comes to drawing, each field checks if it is completely contained in the visible area and draws itself with an offset that we get from from the visible area origin. This worked, but fields that spans multiple columns can completely disappear leaving mostly no fields on the window, so it worked in most cases, but not all. My second trial was about drawing to an ncurses pad that is large enough to fit all contents, then the window is refreshed from that pad. This used manual ncurses calls because we don't support pads at the moment, so I scratched that for now. I think support for pads would be good for those kind of applications in the future. I plan to work on a proposal that would include support for pads and lightweight subwindows, I will detail that later.

Yeah, that is why I was suggesting that we use the list view for fields as it makes scrolling much easier as I really like your graphical approach that you have, it just means scrolling logic is much more complicated.

I eventually opted to create "pages" for the forms. Basically, during form construction, if the number of fields is large and can't fit in the window, the user can call NewPage() to create a new page, all fields after that call gets added to the new page. As the user selects fields, the form can scroll to different pages. This is similar to the ncurses form scrolling functionality. Visual indicator for the current pages and the active page is added to the form if there is more than one page. I hope this solution is satisfactory.

That will work as long as you are wanting to implement all of the required features. I personally like to keep things simple, but I'm not against seeing a nicer solution.

It it were me I would probably make a ListDelegate that can manage a list of delegates where each field would be a delegate and each field would display on one or more line kind of like I detailed in ASCII art. This would make scrolling really easy to implement in an abtract ListDelegate kind of like how we did for the TreeDelegate. For example the "Path" for the executable would take up one line in the list window part of the form. A "Arguments" field for a Process launch dialog could take up one or more lines depending on how many entries the user typed. Same things for the environment variables field we will need. So think about all of the fields types we will need and think about how easy they all will be to implement as we add new things. The fields I can think of include:

• file path (for either a file or directory where constructor of the field specifies which one and also constructor would say if the path needs to exist (which would be true for an executable for a target, but not for a path substitution path)
  • target executable as a file that must exist
  • current working directory as a directory that must exist
  • script path to a file that must exist
• list field (for things like arguments or environment variables where the user specifies one or more items. Each item in the list could use a FieldDelegate so the list can be a list of anything)
  • arguments
  • environment variables
• string field (with optional validation on the string when it loses focus (This could be used to implement the "file path" above where the user types something and then hits tab to select another field, but we don't let the focus change because the path isn't valid or it is expecting a file and a path to a directory is in the field at the moement)
• pulldown to select something. If this was done on a single line, then we can pop up a menu from the menu bar to allow selection
• boolean value
• integer
  • for pid selection for attach dialog where we need to validate the process ID that the user enters is valid
  • for <port> value for a setting that uses sockets

So just think about all the ways we will want to use each of these items and make sure you are willing to support all that is needed to make these happen. If you prefer the more GUI like approach, it will be good for you to understand how much work or support this will involve as new things are added.

[OmarEmaraDev]

• Remove Field type and use FieldDelegate directly

[clayborg]

Just a few questions on how buttons should be handled since we are making new sweeping changes! See inlined comments and let me know what you think

lldb/source/Core/IOHandlerCursesGUI.cpp

1396–1405

Should we put a cancel button and "Submit" button in the window's bottom line to save space? Any errors could be popped up with a modal dialog when the user tries to submit. The help for a form could specify that "Esc" will cancel the dialog and we wouldn't have to write it into the bottom of the window.

1438

As mentioned above, it might be cleaner to put the "Cancel" and "Submit" into the bottom line of the dialog box to save space?

1450

Maybe we want to add a ButtonDelegate class and each window can add a list of button delegates. Then the window draw code would know to draw them?

[OmarEmaraDev]

Since we are still working on this diff. I will add the other form functionality I have been working on here as well if you don't mind.

lldb/source/Core/IOHandlerCursesGUI.cpp

1396–1405

Moving the buttons to the border seems like a good idea to me, so I will do that.

However, I think we should generally avoid double modals, as it is frowned upon in the UX world. So showing errors in a modal is probably not a good idea.

I am currently reworking some aspects of forms to be more dynamic. The new forms supports full vertical scrolling, field validation, per field errors, and list of fields. So errors can be incorporated nicely in the new design.

1450

I guess it depends if we really need this flexibility. I can't think of a form that would need (or should have) more than confirmation and cancellation. Can you give an example where a different configuration would be needed?

[clayborg]

In D104395#2836661, @OmarEmaraDev wrote:

Since we are still working on this diff. I will add the other form functionality I have been working on here as well if you don't mind.

Sure thing!

lldb/source/Core/IOHandlerCursesGUI.cpp

1405

Sounds good! Just want to make sure we do the right thing. I look forward to seeing what you come up with

1450

Just thinking of any window that requires buttons. Forms will have "Cancel" and "OK" or "Submit". Maybe the "Submit" should be a constructor argument so that the target create form can say "Create Target" instead of "Submit"?

We might end up doing modal dialog windows for some settings or validations of fields that pop up a OK/Cancel dialog, or Abort/Retry/Ingore, or a progress dialog that might have a Cancel button. Each of these is a window. Just trying to think ahead of what we will need.

A file picker window would be pretty neat as well, so that when a user selects the "Path" field, maybe a window pops up and allows selecting the file using a nice dialog box, and that maybe have buttons too.

[OmarEmaraDev]

• Add Surface type.
• Add Pad and SubPad types.
• Implement dynamic scrolling.
• Implement per-field validation and error messages.
• Implement File field.
• Implement Directory field.
• Implement List field.
• Refactor field drawing.

[OmarEmaraDev]

Not available in this patch yet:

• Global error messages.
• Contextual scrolling.
• Action bar.
• Auto completion.

[OmarEmaraDev]

• Rewrite internal field navigation.
• Rewrite form window drawing. Form delegate no longer have drawing routines.
• Add global error messages.
• Add action bar. Form delegate can now define as many arbitrary actions as needed.
• Make action button scrollable.
• Add support for composite fields.
• Add backward tab navigation.

[OmarEmaraDev]

• Scrolling was temporarily removed from the patch. It was causing issues with fields that change in size. I will reimplement it as contextual scrolling directly.
• Action buttons weren't moved to the window border as discussed. The window border is already highlighted when the form is active, which makes highlighting and navigating fields not user friendly. Action buttons are now scrollable though, which solves the issue of space.

[OmarEmaraDev]

• Add contextual scrolling support.

[OmarEmaraDev]

Full example:

Example API definition for the above example:

class TestFormDelegate : public FormDelegate {
public:
  TestFormDelegate() {
    m_text_field = AddTextField("Text", "The big brown fox.");
    m_file_field = AddFileField("File", "/tmp/a");
    m_directory_field = AddDirectoryField("Directory", "/tmp/");
    m_pid_field = AddIntegerField("Number", 5);
    std::vector<std::string> choices;
    choices.push_back(std::string("Choice 1"));
    choices.push_back(std::string("Choice 2"));
    choices.push_back(std::string("Choice 3"));
    choices.push_back(std::string("Choice 4"));
    choices.push_back(std::string("Choice 5"));
    m_choices_field = AddChoicesField("Choices", 3, choices);
    m_bool_field = AddBooleanField("Boolean", true);
    TextFieldDelegate default_field =
        TextFieldDelegate("Text", "The big brown fox.");
    m_text_list_field = AddListField("Text List", default_field);

    AddAction("Submit", [this](Window &window) { Submit(window); });
  }

  void Submit(Window &window) { SetError("An example error."); }

protected:
  TextFieldDelegate *m_text_field;
  FileFieldDelegate *m_file_field;
  DirectoryFieldDelegate *m_directory_field;
  IntegerFieldDelegate *m_pid_field;
  BooleanFieldDelegate *m_bool_field;
  ChoicesFieldDelegate *m_choices_field;
  ListFieldDelegate<TextFieldDelegate> *m_text_list_field;
};

[clayborg]

This looks good. Lets get this in so we can start using it.

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>
void Reset(WINDOW *w = nullptr, bool del = true) {
     }
   }
 
   void AttributeOn(attr_t attr) { ::wattron(m_window, attr); }
   void AttributeOff(attr_t attr) { ::wattroff(m_window, attr); }
   void Box(chtype v_char = ACS_VLINE, chtype h_char = ACS_HLINE) {
     ::box(m_window, v_char, h_char);
   }
+  void VerticalLine(int n, chtype v_char = ACS_VLINE) {
+    ::wvline(m_window, v_char, n);
+  }
+  void HorizontalLine(int n, chtype h_char = ACS_HLINE) {
+    ::whline(m_window, h_char, n);
+  }
   void Clear() { ::wclear(m_window); }
   void Erase() { ::werase(m_window); }
   Rect GetBounds() const {
     return Rect(GetParentOrigin(), GetSize());
   } // Get the rectangle in our parent window
   int GetChar() { return ::wgetch(m_window); }
   int GetCursorX() const { return getcurx(m_window); }
   int GetCursorY() const { return getcury(m_window); }
public:
   }
   void PutChar(int ch) { ::waddch(m_window, ch); }
   void PutCString(const char *s, int len = -1) { ::waddnstr(m_window, s, len); }
   void SetBackground(int color_pair_idx) {
     ::wbkgd(m_window, COLOR_PAIR(color_pair_idx));
   }
 
   void PutCStringTruncated(int right_pad, const char *s, int len = -1) {
     int bytes_left = GetWidth() - GetCursorX();
     if (bytes_left > right_pad) {
       bytes_left -= right_pad;
       ::waddnstr(m_window, s, len < 0 ? bytes_left : std::min(bytes_left, len));
     }
   }
 
   void MoveWindow(const Point &origin) {
     const bool moving_window = origin != GetParentOrigin();
     if (m_is_subwin && moving_window) {
       // Can't move subwindows, must delete and re-create
       Size size = GetSize();
       Reset(::subwin(m_parent->m_window, size.height, size.width, origin.y,
                      origin.x),
             true);
if (bottom_message && bottom_message[0]) {
         PutChar('[');
         PutCStringTruncated(1, bottom_message);
       }
     }
     if (attr)
       AttributeOff(attr);
   }
 
+  void DrawBox(const Rect &bounds, chtype v_char = ACS_VLINE,
+               chtype h_char = ACS_HLINE) {
+    MoveCursor(bounds.origin.x, bounds.origin.y);
+    VerticalLine(bounds.size.height);
+    HorizontalLine(bounds.size.width);
+    PutChar(ACS_ULCORNER);
+
+    MoveCursor(bounds.origin.x + bounds.size.width - 1, bounds.origin.y);
+    VerticalLine(bounds.size.height);
+    PutChar(ACS_URCORNER);
+
+    MoveCursor(bounds.origin.x, bounds.origin.y + bounds.size.height - 1);
+    HorizontalLine(bounds.size.width);
+    PutChar(ACS_LLCORNER);
+
+    MoveCursor(bounds.origin.x + bounds.size.width - 1,
+               bounds.origin.y + bounds.size.height - 1);
+    PutChar(ACS_LRCORNER);
+  }
+
+  void DrawTitledBox(const Rect &bounds, const char *title,
+                     chtype v_char = ACS_VLINE, chtype h_char = ACS_HLINE) {
+    DrawBox(bounds, v_char, h_char);
+    int title_offset = 2;
+    MoveCursor(bounds.origin.x + title_offset, bounds.origin.y);
+    PutChar('[');
+    PutCString(title, bounds.size.width - title_offset);
+    PutChar(']');
+  }
+
   virtual void Draw(bool force) {
     if (m_delegate_sp && m_delegate_sp->WindowDelegateDraw(*this, force))
       return;
 
     for (auto &subwindow_sp : m_subwindows)
       subwindow_sp->Draw(force);
   }
 
protected:
   bool m_can_activate;
   bool m_is_subwin;
 
 private:
   Window(const Window &) = delete;
   const Window &operator=(const Window &) = delete;
 };
 
+/////////
+// Forms
+/////////
+
+class FieldDelegate {
+public:
+  virtual ~FieldDelegate() = default;
+
+  virtual Rect FieldDelegateGetBounds() = 0;
+
+  virtual void FieldDelegateDraw(Window &window, bool is_active) = 0;
+
+  virtual HandleCharResult FieldDelegateHandleChar(int key) {
+    return eKeyNotHandled;
+  }
+
+  void FieldDelegateSetPageIndex(int page_index) { m_page_index = page_index; }
+
+  int FieldDelegateGetPageIndex() { return m_page_index; }
+
+protected:
+  // The index of the page this field belongs to.
+  int m_page_index;
+};
+
+typedef std::shared_ptr<FieldDelegate> FieldDelegateSP;
+
+class TextFieldDelegate : public FieldDelegate {
+public:
+  TextFieldDelegate(const char *label, int width, Point origin,
+                    const char *content)
+      : m_label(label), m_width(width), m_origin(origin), m_cursor_position(0),
+        m_first_visibile_char(0) {
+    if (content)
+      m_content = content;
+    assert(m_width > 2);
+  }
+
+  // Get the bounding box of the field. The text field has a height of 3, 2
+  // lines for borders and 1 for the content.
+  Rect FieldDelegateGetBounds() override {
+    return Rect(m_origin, Size(m_width, 3));
+  }
+
+  // Get the start X position of the content in window space, without the
+  // borders.
+  int GetX() { return m_origin.x + 1; }
+
+  // Get the start Y position of the content in window space, without the
+  // borders.
+  int GetY() { return m_origin.y + 1; }
+
+  // Get the effective width of the field, without the borders.
+  int GetEffectiveWidth() { return m_width - 2; }
+
+  // Get the cursor position in window space.
+  int GetCursorWindowXPosition() {
+    return GetX() + m_cursor_position - m_first_visibile_char;
+  }
+
+  int GetContentLength() { return m_content.length(); }
+
+  void FieldDelegateDraw(Window &window, bool is_active) override {
+    // Draw label box.
+    window.DrawTitledBox(FieldDelegateGetBounds(), m_label.c_str());
+
+    // Draw content.
+    window.MoveCursor(GetX(), GetY());
+    const char *text = m_content.c_str() + m_first_visibile_char;
+    window.PutCString(text, GetEffectiveWidth());
+
+    // Highlight the cursor.
+    window.MoveCursor(GetCursorWindowXPosition(), GetY());
+    if (is_active)
+      window.AttributeOn(A_REVERSE);
+    if (m_cursor_position == GetContentLength())
+      // Cursor is past the last character. Highlight an empty space.
+      window.PutChar(' ');
+    else
+      window.PutChar(m_content[m_cursor_position]);
+    if (is_active)
+      window.AttributeOff(A_REVERSE);
+  }
+
+  // The cursor is allowed to move one character past the string.
+  // m_cursor_position is in range [0, GetContentLength()].
+  void MoveCursorRight() {
+    if (m_cursor_position < GetContentLength())
+      m_cursor_position++;
+  }
+
+  void MoveCursorLeft() {
+    if (m_cursor_position > 0)
+      m_cursor_position--;
+  }
+
+  // If the cursor moved past the last visible character, scroll right by one
+  // character.
+  void ScrollRightIfNeeded() {
+    if (m_cursor_position - m_first_visibile_char == GetEffectiveWidth())
+      m_first_visibile_char++;
+  }
+
+  void ScrollLeft() {
+    if (m_first_visibile_char > 0)
+      m_first_visibile_char--;
+  }
+
+  // If the cursor moved past the first visible character, scroll left by one
+  // character.
+  void ScrollLeftIfNeeded() {
+    if (m_cursor_position < m_first_visibile_char)
+      m_first_visibile_char--;
+  }
+
+  // Insert a character at the current cursor position, advance the cursor
+  // position, and make sure to scroll right if needed.
+  void InsertChar(char character) {
+    m_content.insert(m_cursor_position, 1, character);
+    m_cursor_position++;
+    ScrollRightIfNeeded();
+  }
+
+  // Remove the character before the cursor position, retreat the cursor
+  // position, and make sure to scroll left if needed.
+  void RemoveChar() {
+    if (m_cursor_position == 0)
+      return;
+
+    m_content.erase(m_cursor_position - 1, 1);
+    m_cursor_position--;
+    ScrollLeft();
+  }
+
+  // True if the key represents a char that can be inserted in the field
+  // content, false otherwise.
+  virtual bool IsAcceptableChar(int key) { return isprint(key); }
+
+  HandleCharResult FieldDelegateHandleChar(int key) override {
+    if (IsAcceptableChar(key)) {
+      InsertChar((char)key);
+      return eKeyHandled;
+    }
+
+    switch (key) {
+    case KEY_RIGHT:
+      MoveCursorRight();
+      ScrollRightIfNeeded();
+      return eKeyHandled;
+    case KEY_LEFT:
+      MoveCursorLeft();
+      ScrollLeftIfNeeded();
+      return eKeyHandled;
+    case KEY_BACKSPACE:
+      RemoveChar();
+      return eKeyHandled;
+    default:
+      break;
+    }
+    return eKeyNotHandled;
+  }
+
+  // Returns the text content of the field.
+  const std::string &GetText() { return m_content; }
+
+protected:
+  std::string m_label;
+  // The total width of the field, including the two border characters. So the
+  // effective width is two characters less.
+  int m_width;
+  // The position of the top left corner character of the border.
+  Point m_origin;
+  std::string m_content;
+  // The cursor position in the content string itself. Can be in the range
+  // [0, GetContentLength()].
+  int m_cursor_position;
+  // The index of the first visible character in the content.
+  int m_first_visibile_char;
+};
+
+class IntegerFieldDelegate : public TextFieldDelegate {
+public:
+  IntegerFieldDelegate(const char *label, int width, Point origin, int content)
+      : TextFieldDelegate(label, width, origin,
+                          std::to_string(content).c_str()) {}
+
+  // Only accept digits.
+  bool IsAcceptableChar(int key) override { return isdigit(key); }
+
+  // Returns the integer content of the field.
+  int GetInteger() { return std::stoi(m_content); }
+};
+
+class BooleanFieldDelegate : public FieldDelegate {
+public:
+  BooleanFieldDelegate(const char *label, Point origin, bool content)
+      : m_label(label), m_origin(origin), m_content(content) {}
+
+  // Get the bounding box of the field. The boolean field is drawn as follows:
+  // [X] Label  or [ ] Label
+  // So 4 characters plus the length of the label. And only a single line.
+  Rect FieldDelegateGetBounds() override {
+    return Rect(m_origin, Size(4 + m_label.length(), 1));
+  }
+
+  // [X] Label  or [ ] Label
+  void FieldDelegateDraw(Window &window, bool is_active) override {
+    window.MoveCursor(m_origin.x, m_origin.y);
+    window.PutChar('[');
+    if (is_active)
+      window.AttributeOn(A_REVERSE);
+    window.PutChar(m_content ? ACS_DIAMOND : ' ');
+    if (is_active)
+      window.AttributeOff(A_REVERSE);
+    window.PutChar(']');
+    window.PutChar(' ');
+    window.PutCString(m_label.c_str());
+  }
+
+  void ToggleContent() { m_content = !m_content; }
+
+  void SetContentToTrue() { m_content = true; }
+
+  void SetContentToFalse() { m_content = false; }
+
+  HandleCharResult FieldDelegateHandleChar(int key) override {
+    switch (key) {
+    case 't':
+    case '1':
+      SetContentToTrue();
+      return eKeyHandled;
+    case 'f':
+    case '0':
+      SetContentToFalse();
+      return eKeyHandled;
+    case ' ':
+    case '\r':
+    case '\n':
+    case KEY_ENTER:
+      ToggleContent();
+      return eKeyHandled;
+    default:
+      break;
+    }
+    return eKeyNotHandled;
+  }
+
+  // Returns the boolean content of the field.
+  bool GetBoolean() { return m_content; }
+
+protected:
+  std::string m_label;
+  // The window space position of the first character.
+  Point m_origin;
+  bool m_content;
+};
+
+class ChoicesFieldDelegate : public FieldDelegate {
+public:
+  ChoicesFieldDelegate(const char *label, int width, int height, Point origin,
+                       std::vector<std::string> choices)
+      : m_label(label), m_width(width), m_height(height), m_origin(origin),
+        m_choices(choices), m_choice(0), m_first_visibile_choice(0) {
+    assert(m_width > 3);
+    assert(m_height > 2);
+  }
+
+  // Get the bounding box of the field. The height is 2 border characters with
+  // one or more space to show choices in a list.
+  Rect FieldDelegateGetBounds() override {
+    return Rect(m_origin, Size(m_width, m_height));
+  }
+
+  // Get the X position of the choices in window space, without the borders.
+  int GetX() { return m_origin.x + 1; }
+
+  // Get the Y position of the first visible choice in window space.
+  int GetY() { return m_origin.y + 1; }
+
+  // Get the effective width of the field, without the borders.
+  int GetEffectiveWidth() { return m_width - 2; }
+  //
+  // Get the effective height of the field, without the borders.
+  int GetEffectiveHeight() { return m_height - 2; }
+
+  int GetNumberOfChoices() { return m_choices.size(); }
+
+  // Get the index of the last visible choice.
+  int GetLastVisibleChoice() {
+    return std::min(m_first_visibile_choice + GetEffectiveHeight() - 1,
+                    GetNumberOfChoices() - 1);
+  }
+
+  void FieldDelegateDraw(Window &window, bool is_active) override {
+    // Draw label box.
+    window.DrawTitledBox(FieldDelegateGetBounds(), m_label.c_str());
+
+    // Draw content.
+    int choices_to_draw = GetLastVisibleChoice() - m_first_visibile_choice + 1;
+    for (int i = 0; i < choices_to_draw; i++) {
+      window.MoveCursor(GetX(), GetY() + i);
+      int current_choice = m_first_visibile_choice + i;
+      const char *text = m_choices[current_choice].c_str();
+      bool highlight = is_active && current_choice == m_choice;
+      if (highlight)
+        window.AttributeOn(A_REVERSE);
+      window.PutChar(current_choice == m_choice ? ACS_DIAMOND : ' ');
+      window.PutCString(text);
+      if (highlight)
+        window.AttributeOff(A_REVERSE);
+    }
+  }
+
+  void SelectPrevious() {
+    if (m_choice > 0)
+      m_choice--;
+  }
+
+  void SelectNext() {
+    if (m_choice < GetNumberOfChoices() - 1)
+      m_choice++;
+  }
+
+  // If the cursor moved past the first visible choice, scroll up by one
+  // choice.
+  void ScrollUpIfNeeded() {
+    if (m_choice < m_first_visibile_choice)
+      m_first_visibile_choice--;
+  }
+
+  // If the cursor moved past the last visible choice, scroll down by one
+  // choice.
+  void ScrollDownIfNeeded() {
+    if (m_choice > GetLastVisibleChoice())
+      m_first_visibile_choice++;
+  }
+
+  HandleCharResult FieldDelegateHandleChar(int key) override {
+    switch (key) {
+    case KEY_UP:
+      SelectPrevious();
+      ScrollUpIfNeeded();
+      return eKeyHandled;
+    case KEY_DOWN:
+      SelectNext();
+      ScrollDownIfNeeded();
+      return eKeyHandled;
+    default:
+      break;
+    }
+    return eKeyNotHandled;
+  }
+
+  // Returns the content of the choice as a string.
+  std::string GetChoiceContent() { return m_choices[m_choice]; }
+
+  // Returns the index of the choice.
+  int GetChoice() { return m_choice; }
+
+protected:
+  std::string m_label;
+  // The total width of the field, including the two border characters. So the
+  // effective width is two characters less.
+  int m_width;
+  // The total height of the field, including the two border characters. So the
+  // effective width is two characters less.
+  int m_height;
+  // The position of the top left corner character of the border.
+  Point m_origin;
+  std::vector<std::string> m_choices;
+  // The index of the selected choice.
+  int m_choice;
+  // The index of the first visible choice in the field.
+  int m_first_visibile_choice;
+};
+
+class FormDelegate {
+public:
+  FormDelegate() : m_has_error(false), m_last_page_index(0) {}
+
+  virtual ~FormDelegate() = default;
+
+  virtual HandleCharResult FormDelegateHandleChar(int selected_field_index,
+                                                  int key) {
+    return m_fields[selected_field_index]->FieldDelegateHandleChar(key);
+  }
+
+  virtual void FormDelegateDraw(Window &window, int selected_field_index) {
+    int active_page_index = GetActivePageIndex(selected_field_index);
+    for (int i = 0; i < GetNumberOfFields(); i++) {
+      if (m_fields[i]->FieldDelegateGetPageIndex() != active_page_index)
+        continue;
+
+      bool is_field_selected = selected_field_index == i;
+      m_fields[i]->FieldDelegateDraw(window, is_field_selected);
+    }
+  }
+
+  // Return true if submission was successful, false otherwise. If false, the
+  // method should set the m_error member to an appropriate error message.
+  virtual bool FormDelegateSubmit() = 0;
+
+  int GetNumberOfFields() { return m_fields.size(); }
+
+  bool HasError() { return m_has_error; }
+
+  std::string &GetError() { return m_error; }
+
+  // Return the index of the page that includes the selected field. If no field
+  // is selected, that is, if the selected field index is not in the correct
+  // range, return the last page index.
+  int GetActivePageIndex(int selected_field_index) {
+    if (selected_field_index < GetNumberOfFields())
+      return m_fields[selected_field_index]->FieldDelegateGetPageIndex();
+    return m_last_page_index;
+  }
+
+  int GetNumberOfPages() { return m_last_page_index + 1; }
+
+  // Factory methods to create and add fields of specific types.
+
+  TextFieldDelegate *AddTextField(const char *label, int width, Point origin,
+                                  const char *content) {
+    TextFieldDelegate *delegate =
+        new TextFieldDelegate(label, width, origin, content);
+    FieldDelegateSP delegate_sp = FieldDelegateSP(delegate);
+    delegate_sp->FieldDelegateSetPageIndex(m_last_page_index);
+    m_fields.push_back(delegate_sp);
+    return delegate;
+  }
+
+  IntegerFieldDelegate *AddIntegerField(const char *label, int width,
+                                        Point origin, int content) {
+    IntegerFieldDelegate *delegate =
+        new IntegerFieldDelegate(label, width, origin, content);
+    FieldDelegateSP delegate_sp = FieldDelegateSP(delegate);
+    delegate_sp->FieldDelegateSetPageIndex(m_last_page_index);
+    m_fields.push_back(delegate_sp);
+    return delegate;
+  }
+
+  BooleanFieldDelegate *AddBooleanField(const char *label, Point origin,
+                                        bool content) {
+    BooleanFieldDelegate *delegate =
+        new BooleanFieldDelegate(label, origin, content);
+    FieldDelegateSP delegate_sp = FieldDelegateSP(delegate);
+    delegate_sp->FieldDelegateSetPageIndex(m_last_page_index);
+    m_fields.push_back(delegate_sp);
+    return delegate;
+  }
+
+  ChoicesFieldDelegate *AddChoicesField(const char *label, int width,
+                                        int height, Point origin,
+                                        std::vector<std::string> choices) {
+    ChoicesFieldDelegate *delegate =
+        new ChoicesFieldDelegate(label, width, height, origin, choices);
+    FieldDelegateSP delegate_sp = FieldDelegateSP(delegate);
+    delegate_sp->FieldDelegateSetPageIndex(m_last_page_index);
+    m_fields.push_back(delegate_sp);
+    return delegate;
+  }
+
+  void NewPage() { m_last_page_index++; }
+
+protected:
+  bool m_has_error;
+  std::string m_error;
+  std::vector<FieldDelegateSP> m_fields;
+  // The index of the last page.
+  int m_last_page_index;
+};
+
+typedef std::shared_ptr<FormDelegate> FormDelegateSP;
+
+class FormWindowDelegate : public WindowDelegate {
+public:
+  FormWindowDelegate(FormDelegateSP &delegate_sp)
+      : m_delegate_sp(delegate_sp), m_selected_field_index(0) {}
+
+  // A form window is divided into two sections. A body section which is padded
+  // by one character from every direction and contains the fields. The body can
+  // have multiple "pages" which are switched automatically as the user selects
+  // next fields. The number of pages is signified by a number of centered dots
+  // at the last line of the body section, the active page will have its dot
+  // highlighted. Additionally a footer section contains the submit button in
+  // one line and a possible error message in the next line. Finally, a
+  // horizontal line separates both sections.
+  //
+  // ___<Form Name>_________________________________________________
+  // |                                                             |
+  // |                                                             |
+  // | Form elements here.                                         |
+  // |                                                             |
+  // |                            ...                              |
+  // |-------------------------------------------------------------|
+  // |                         [ SUBMIT ]                          |
+  // | Error message if it exists.                                 |
+  // |______________________________________[Press Esc to cancel]__|
+  //
+  // The following methods describe this structure in numbers.
+
+  int GetPageIndicatorYLocation(Window &window) {
+    return window.GetHeight() - 5;
+  }
+
+  int GetSeparatorYLocation(Window &window) { return window.GetHeight() - 4; }
+
+  int GetButtonYLocation(Window &window) { return window.GetHeight() - 3; }
+
+  void DrawPageIndicators(Window &window) {
+    int number_of_pages = m_delegate_sp->GetNumberOfPages();
+    if (number_of_pages == 1) {
+      return;
+    }
+    int x = (window.GetWidth() - number_of_pages) / 2;
+    window.MoveCursor(x, GetPageIndicatorYLocation(window));
+    int active_page = m_delegate_sp->GetActivePageIndex(m_selected_field_index);
+    for (int i = 0; i < number_of_pages; i++) {
+      bool is_active = active_page == i;
+      if (is_active)
+        window.AttributeOn(A_REVERSE);
+      window.PutChar(ACS_BULLET);
+      if (is_active)
+        window.AttributeOff(A_REVERSE);
+    }
+  }
+
+  bool WindowDelegateDraw(Window &window, bool force) override {
+    window.Erase();
+
+    window.DrawTitleBox(window.GetName(), "Press Esc to cancel");
+
+    // Draw field elements.
+    m_delegate_sp->FormDelegateDraw(window, m_selected_field_index);
+
+    // Draw a horizontal line separating the fields and the submit button.
+    window.MoveCursor(1, GetSeparatorYLocation(window));
+    window.HorizontalLine(window.GetWidth() - 2);
+
+    DrawPageIndicators(window);
+
+    // Draw the centered submit button.
+    const char *button_text = "[Submit]";
+    int x = (window.GetWidth() - sizeof(button_text) - 1) / 2;
+    window.MoveCursor(x, GetButtonYLocation(window));
+    if (IsButtonActive())
+      window.AttributeOn(A_REVERSE);
+    window.PutCString(button_text);
+    if (IsButtonActive())
+      window.AttributeOff(A_REVERSE);
+
+    // Draw the error if it exists.
+    if (m_delegate_sp->HasError()) {
+      window.MoveCursor(2, window.GetHeight() - 2);
+      window.AttributeOn(COLOR_PAIR(RedOnBlack));
+      window.PutChar(ACS_DIAMOND);
+      window.PutChar(' ');
+      window.PutCStringTruncated(1, m_delegate_sp->GetError().c_str());
+      window.AttributeOff(COLOR_PAIR(RedOnBlack));
+    }
+
+    return true;
+  }
+
+  // The index can be equal to the number of fields, hence the plus one. See
+  // IsButtonActive().
+  void SelectedNextField() {
+    m_selected_field_index++;
+    int number_of_fields = m_delegate_sp->GetNumberOfFields();
+    m_selected_field_index %= number_of_fields + 1;
+  }
+
+  void SubmitForm(Window &window) {
+    bool is_successful = m_delegate_sp->FormDelegateSubmit();
+    if (is_successful)
+      window.GetParent()->RemoveSubWindow(&window);
+  }
+
+  HandleCharResult WindowDelegateHandleChar(Window &window, int key) override {
+    switch (key) {
+    case '\r':
+    case '\n':
+    case KEY_ENTER:
+      if (IsButtonActive()) {
+        SubmitForm(window);
+        return eKeyHandled;
+      }
+      break;
+    case '\t':
+      SelectedNextField();
+      return eKeyHandled;
+    case KEY_ESCAPE:
+      window.GetParent()->RemoveSubWindow(&window);
+      return eKeyHandled;
+    default:
+      break;
+    }
+
+    // If the key wasn't handled and one of the fields is active, pass the key
+    // to that field.
+    if (!IsButtonActive()) {
+      return m_delegate_sp->FormDelegateHandleChar(m_selected_field_index, key);
+    }
+
+    return eKeyNotHandled;
+  }
+
+  // When the selected field index is equal to the number of selected fields,
+  // this denotes that the submit button is selected.
+  bool IsButtonActive() {
+    int number_of_fields = m_delegate_sp->GetNumberOfFields();
+    return m_selected_field_index == number_of_fields;
+  }
+
+protected:
+  FormDelegateSP m_delegate_sp;
+  // The index of the selected field. This can be equal to the number of fields,
+  // in which case, it denotes that the submit button is selected.
+  int m_selected_field_index;
+};
+
 class MenuDelegate {
 public:
   virtual ~MenuDelegate() = default;
 
   virtual MenuActionResult MenuDelegateAction(Menu &menu) = 0;
 };
 
 class Menu : public WindowDelegate {