lldb/source/Core/IOHandler.cpp

//===-- IOHandler.cpp -------------------------------------------*- C++ -*-===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

// C Includes
#ifndef LLDB_DISABLE_CURSES
#include <curses.h>
#include <panel.h>
#endif

// C++ Includes
#if defined(__APPLE__)
#include <deque>
#endif
#include <string>

// Other libraries and framework includes
// Project includes
#include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Core/IOHandler.h"
#include "lldb/Core/Debugger.h"
#include "lldb/Core/Module.h"
#include "lldb/Core/State.h"
#include "lldb/Core/StreamFile.h"
#include "lldb/Core/ValueObjectRegister.h"
#ifndef LLDB_DISABLE_LIBEDIT
#include "lldb/Host/Editline.h"
#endif
#include "lldb/Interpreter/CommandCompletions.h"
#include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Symbol/Block.h"
#include "lldb/Symbol/Function.h"
#include "lldb/Symbol/Symbol.h"
#include "lldb/Target/RegisterContext.h"
#include "lldb/Target/ThreadPlan.h"



using namespace lldb;
using namespace lldb_private;

IOHandler::IOHandler (Debugger &debugger, IOHandler::Type type) :
    IOHandler (debugger,
               type,
               StreamFileSP(),  // Adopt STDIN from top input reader
               StreamFileSP(),  // Adopt STDOUT from top input reader
               StreamFileSP(),  // Adopt STDERR from top input reader
               0)               // Flags
{
}

IOHandler::IOHandler (Debugger &debugger,
                      IOHandler::Type type,
                      const lldb::StreamFileSP &input_sp,
                      const lldb::StreamFileSP &output_sp,
                      const lldb::StreamFileSP &error_sp,
                      uint32_t flags) :
    m_debugger (debugger),
    m_input_sp (input_sp),
    m_output_sp (output_sp),
    m_error_sp (error_sp),
    m_popped (false),
    m_flags (flags),
    m_type (type),
    m_user_data (NULL),
    m_done (false),
    m_active (false)
{
    // If any files are not specified, then adopt them from the top input reader.
    if (!m_input_sp || !m_output_sp || !m_error_sp)
        debugger.AdoptTopIOHandlerFilesIfInvalid (m_input_sp,
                                                  m_output_sp,
                                                  m_error_sp);
}

IOHandler::~IOHandler() = default;

int
IOHandler::GetInputFD()
{
    if (m_input_sp)
        return m_input_sp->GetFile().GetDescriptor();
    return -1;
}

int
IOHandler::GetOutputFD()
{
    if (m_output_sp)
        return m_output_sp->GetFile().GetDescriptor();
    return -1;
}

int
IOHandler::GetErrorFD()
{
    if (m_error_sp)
        return m_error_sp->GetFile().GetDescriptor();
    return -1;
}

FILE *
IOHandler::GetInputFILE()
{
    if (m_input_sp)
        return m_input_sp->GetFile().GetStream();
    return NULL;
}

FILE *
IOHandler::GetOutputFILE()
{
    if (m_output_sp)
        return m_output_sp->GetFile().GetStream();
    return NULL;
}

FILE *
IOHandler::GetErrorFILE()
{
    if (m_error_sp)
        return m_error_sp->GetFile().GetStream();
    return NULL;
}

StreamFileSP &
IOHandler::GetInputStreamFile()
{
    return m_input_sp;
}

StreamFileSP &
IOHandler::GetOutputStreamFile()
{
    return m_output_sp;
}

StreamFileSP &
IOHandler::GetErrorStreamFile()
{
    return m_error_sp;
}

bool
IOHandler::GetIsInteractive ()
{
    return GetInputStreamFile()->GetFile().GetIsInteractive ();
}

bool
IOHandler::GetIsRealTerminal ()
{
    return GetInputStreamFile()->GetFile().GetIsRealTerminal();
}

void
IOHandler::SetPopped (bool b)
{
    m_popped.SetValue(b, eBroadcastOnChange);
}

void
IOHandler::WaitForPop ()
{
    m_popped.WaitForValueEqualTo(true);
}

void
IOHandlerStack::PrintAsync (Stream *stream, const char *s, size_t len)
{
    if (stream)
    {
        Mutex::Locker locker (m_mutex);
        if (m_top)
            m_top->PrintAsync (stream, s, len);
    }
}

IOHandlerConfirm::IOHandlerConfirm (Debugger &debugger,
                                    const char *prompt,
                                    bool default_response) :
    IOHandlerEditline(debugger,
                      IOHandler::Type::Confirm,
                      NULL,     // NULL editline_name means no history loaded/saved
                      NULL,     // No prompt
                      NULL,     // No continuation prompt
                      false,    // Multi-line
                      false,    // Don't colorize the prompt (i.e. the confirm message.)
                      0,
                      *this),
    m_default_response (default_response),
    m_user_response (default_response)
{
    StreamString prompt_stream;
    prompt_stream.PutCString(prompt);
    if (m_default_response)
        prompt_stream.Printf(": [Y/n] ");
    else
        prompt_stream.Printf(": [y/N] ");
    
    SetPrompt (prompt_stream.GetString().c_str());
    
}

IOHandlerConfirm::~IOHandlerConfirm() = default;

int
IOHandlerConfirm::IOHandlerComplete (IOHandler &io_handler,
                                     const char *current_line,
                                     const char *cursor,
                                     const char *last_char,
                                     int skip_first_n_matches,
                                     int max_matches,
                                     StringList &matches)
{
    if (current_line == cursor)
    {
        if (m_default_response)
        {
            matches.AppendString("y");
        }
        else
        {
            matches.AppendString("n");
        }
    }
    return matches.GetSize();
}

void
IOHandlerConfirm::IOHandlerInputComplete (IOHandler &io_handler, std::string &line)
{
    if (line.empty())
    {
        // User just hit enter, set the response to the default
        m_user_response = m_default_response;
        io_handler.SetIsDone(true);
        return;
    }

    if (line.size() == 1)
    {
        switch (line[0])
        {
            case 'y':
            case 'Y':
                m_user_response = true;
                io_handler.SetIsDone(true);
                return;
            case 'n':
            case 'N':
                m_user_response = false;
                io_handler.SetIsDone(true);
                return;
            default:
                break;
        }
    }

    if (line == "yes" || line == "YES" || line == "Yes")
    {
        m_user_response = true;
        io_handler.SetIsDone(true);
    }
    else if (line == "no" || line == "NO" || line == "No")
    {
        m_user_response = false;
        io_handler.SetIsDone(true);
    }
}

int
IOHandlerDelegate::IOHandlerComplete (IOHandler &io_handler,
                                      const char *current_line,
                                      const char *cursor,
                                      const char *last_char,
                                      int skip_first_n_matches,
                                      int max_matches,
                                      StringList &matches)
{
    switch (m_completion)
    {
    case Completion::None:
        break;

    case Completion::LLDBCommand:
        return io_handler.GetDebugger().GetCommandInterpreter().HandleCompletion (current_line,
                                                                                  cursor,
                                                                                  last_char,
                                                                                  skip_first_n_matches,
                                                                                  max_matches,
                                                                                  matches);

    case Completion::Expression:
        {
            bool word_complete = false;
            const char *word_start = cursor;
            if (cursor > current_line)
                --word_start;
            while (word_start > current_line && !isspace(*word_start))
                --word_start;
            CommandCompletions::InvokeCommonCompletionCallbacks (io_handler.GetDebugger().GetCommandInterpreter(),
                                                                 CommandCompletions::eVariablePathCompletion,
                                                                 word_start,
                                                                 skip_first_n_matches,
                                                                 max_matches,
                                                                 NULL,
                                                                 word_complete,
                                                                 matches);
            
            size_t num_matches = matches.GetSize();
            if (num_matches > 0)
            {
                std::string common_prefix;
                matches.LongestCommonPrefix (common_prefix);
                const size_t partial_name_len = strlen(word_start);
                
                // If we matched a unique single command, add a space...
                // Only do this if the completer told us this was a complete word, however...
                if (num_matches == 1 && word_complete)
                {
                    common_prefix.push_back(' ');
                }
                common_prefix.erase (0, partial_name_len);
                matches.InsertStringAtIndex(0, std::move(common_prefix));
            }
            return num_matches;
        }
        break;
    }
    
    return 0;
}

IOHandlerEditline::IOHandlerEditline (Debugger &debugger,
                                      IOHandler::Type type,
                                      const char *editline_name, // Used for saving history files
                                      const char *prompt,
                                      const char *continuation_prompt,
                                      bool multi_line,
                                      bool color_prompts,
                                      uint32_t line_number_start,
                                      IOHandlerDelegate &delegate) :
    IOHandlerEditline(debugger,
                      type,
                      StreamFileSP(), // Inherit input from top input reader
                      StreamFileSP(), // Inherit output from top input reader
                      StreamFileSP(), // Inherit error from top input reader
                      0,              // Flags
                      editline_name,  // Used for saving history files
                      prompt,
                      continuation_prompt,
                      multi_line,
                      color_prompts,
                      line_number_start,
                      delegate)
{
}

IOHandlerEditline::IOHandlerEditline (Debugger &debugger,
                                      IOHandler::Type type,
                                      const lldb::StreamFileSP &input_sp,
                                      const lldb::StreamFileSP &output_sp,
                                      const lldb::StreamFileSP &error_sp,
                                      uint32_t flags,
                                      const char *editline_name, // Used for saving history files
                                      const char *prompt,
                                      const char *continuation_prompt,
                                      bool multi_line,
                                      bool color_prompts,
                                      uint32_t line_number_start,
                                      IOHandlerDelegate &delegate) :
    IOHandler (debugger, type, input_sp, output_sp, error_sp, flags),
#ifndef LLDB_DISABLE_LIBEDIT
    m_editline_ap (),
#endif
    m_delegate (delegate),
    m_prompt (),
    m_continuation_prompt(),
    m_current_lines_ptr (NULL),
    m_base_line_number (line_number_start),
    m_curr_line_idx (UINT32_MAX),
    m_multi_line (multi_line),
    m_color_prompts (color_prompts),
    m_interrupt_exits (true),
    m_editing (false)
{
    SetPrompt(prompt);

#ifndef LLDB_DISABLE_LIBEDIT
    bool use_editline = false;
    
    use_editline = m_input_sp->GetFile().GetIsRealTerminal();

    if (use_editline)
    {
        m_editline_ap.reset(new Editline (editline_name,
                                          GetInputFILE (),
                                          GetOutputFILE (),
                                          GetErrorFILE (),
                                          m_color_prompts));
        m_editline_ap->SetIsInputCompleteCallback (IsInputCompleteCallback, this);
        m_editline_ap->SetAutoCompleteCallback (AutoCompleteCallback, this);
        // See if the delegate supports fixing indentation
        const char *indent_chars = delegate.IOHandlerGetFixIndentationCharacters();
        if (indent_chars)
        {
            // The delegate does support indentation, hook it up so when any indentation
            // character is typed, the delegate gets a chance to fix it
            m_editline_ap->SetFixIndentationCallback (FixIndentationCallback, this, indent_chars);
        }
    }
#endif
    SetBaseLineNumber (m_base_line_number);
    SetPrompt(prompt ? prompt : "");
    SetContinuationPrompt(continuation_prompt);    
}

IOHandlerEditline::~IOHandlerEditline ()
{
#ifndef LLDB_DISABLE_LIBEDIT
    m_editline_ap.reset();
#endif
}

void
IOHandlerEditline::Activate ()
{
    IOHandler::Activate();
    m_delegate.IOHandlerActivated(*this);
}

void
IOHandlerEditline::Deactivate ()
{
    IOHandler::Deactivate();
    m_delegate.IOHandlerDeactivated(*this);
}

bool
IOHandlerEditline::GetLine (std::string &line, bool &interrupted)
{
#ifndef LLDB_DISABLE_LIBEDIT
    if (m_editline_ap)
    {
        return m_editline_ap->GetLine (line, interrupted);
    }
    else
    {
#endif
        line.clear();

        FILE *in = GetInputFILE();
        if (in)
        {
            if (GetIsInteractive())
            {
                const char *prompt = NULL;
                
                if (m_multi_line && m_curr_line_idx > 0)
                    prompt = GetContinuationPrompt();
                
                if (prompt == NULL)
                    prompt = GetPrompt();
                
                if (prompt && prompt[0])
                {
                    FILE *out = GetOutputFILE();
                    if (out)
                    {
                        ::fprintf(out, "%s", prompt);
                        ::fflush(out);
                    }
                }
            }
            char buffer[256];
            bool done = false;
            bool got_line = false;
            m_editing = true;
            while (!done)
            {
                if (fgets(buffer, sizeof(buffer), in) == NULL)
                {
                    const int saved_errno = errno;
                    if (feof(in))
                        done = true;
                    else if (ferror(in))
                    {
                        if (saved_errno != EINTR)
                            done = true;
                    }
                }
                else
                {
                    got_line = true;
                    size_t buffer_len = strlen(buffer);
                    assert (buffer[buffer_len] == '\0');
                    char last_char = buffer[buffer_len-1];
                    if (last_char == '\r' || last_char == '\n')
                    {
                        done = true;
                        // Strip trailing newlines
                        while (last_char == '\r' || last_char == '\n')
                        {
                            --buffer_len;
                            if (buffer_len == 0)
                                break;
                            last_char = buffer[buffer_len-1];
                        }
                    }
                    line.append(buffer, buffer_len);
                }
            }
            m_editing = false;
            // We might have gotten a newline on a line by itself
            // make sure to return true in this case.
            return got_line;
        }
        else
        {
            // No more input file, we are done...
            SetIsDone(true);
        }
        return false;
#ifndef LLDB_DISABLE_LIBEDIT
    }
#endif
}


#ifndef LLDB_DISABLE_LIBEDIT
bool
IOHandlerEditline::IsInputCompleteCallback (Editline *editline,
                                          StringList &lines,
                                          void *baton)
{
    IOHandlerEditline *editline_reader = (IOHandlerEditline *) baton;
    return editline_reader->m_delegate.IOHandlerIsInputComplete(*editline_reader, lines);
}

int
IOHandlerEditline::FixIndentationCallback (Editline *editline,
                                           const StringList &lines,
                                           int cursor_position,
                                           void *baton)
{
    IOHandlerEditline *editline_reader = (IOHandlerEditline *) baton;
    return editline_reader->m_delegate.IOHandlerFixIndentation(*editline_reader, lines, cursor_position);
}

int
IOHandlerEditline::AutoCompleteCallback (const char *current_line,
                                         const char *cursor,
                                         const char *last_char,
                                         int skip_first_n_matches,
                                         int max_matches,
                                         StringList &matches,
                                         void *baton)
{
    IOHandlerEditline *editline_reader = (IOHandlerEditline *) baton;
    if (editline_reader)
        return editline_reader->m_delegate.IOHandlerComplete (*editline_reader,
                                                              current_line,
                                                              cursor,
                                                              last_char,
                                                              skip_first_n_matches,
                                                              max_matches,
                                                              matches);
    return 0;
}
#endif

const char *
IOHandlerEditline::GetPrompt ()
{
#ifndef LLDB_DISABLE_LIBEDIT
    if (m_editline_ap)
    {
        return m_editline_ap->GetPrompt ();
    }
    else
    {
#endif
        if (m_prompt.empty())
            return NULL;
#ifndef LLDB_DISABLE_LIBEDIT
    }
#endif
    return m_prompt.c_str();
}

bool
IOHandlerEditline::SetPrompt (const char *p)
{
    if (p && p[0])
        m_prompt = p;
    else
        m_prompt.clear();
#ifndef LLDB_DISABLE_LIBEDIT
    if (m_editline_ap)
        m_editline_ap->SetPrompt (m_prompt.empty() ? NULL : m_prompt.c_str());
#endif
    return true;
}

const char *
IOHandlerEditline::GetContinuationPrompt ()
{
    if (m_continuation_prompt.empty())
        return NULL;
    return m_continuation_prompt.c_str();
}

void
IOHandlerEditline::SetContinuationPrompt (const char *p)
{
    if (p && p[0])
        m_continuation_prompt = p;
    else
        m_continuation_prompt.clear();

#ifndef LLDB_DISABLE_LIBEDIT
    if (m_editline_ap)
        m_editline_ap->SetContinuationPrompt (m_continuation_prompt.empty() ? NULL : m_continuation_prompt.c_str());
#endif
}

void
IOHandlerEditline::SetBaseLineNumber (uint32_t line)
{
    m_base_line_number = line;
}

uint32_t
IOHandlerEditline::GetCurrentLineIndex () const
{
#ifndef LLDB_DISABLE_LIBEDIT
    if (m_editline_ap)
        return m_editline_ap->GetCurrentLine();
#endif
    return m_curr_line_idx;
}

bool
IOHandlerEditline::GetLines (StringList &lines, bool &interrupted)
{
    m_current_lines_ptr = &lines;
    
    bool success = false;
#ifndef LLDB_DISABLE_LIBEDIT
    if (m_editline_ap)
    {
        return m_editline_ap->GetLines (m_base_line_number, lines, interrupted);
    }
    else
    {
#endif
        bool done = false;
        Error error;

        while (!done)
        {
            // Show line numbers if we are asked to
            std::string line;
            if (m_base_line_number > 0 && GetIsInteractive())
            {
                FILE *out = GetOutputFILE();
                if (out)
                    ::fprintf(out, "%u%s", m_base_line_number + (uint32_t)lines.GetSize(), GetPrompt() == NULL ? " " : "");
            }
            
            m_curr_line_idx = lines.GetSize();
            
            bool interrupted = false;
            if (GetLine(line, interrupted) && !interrupted)
            {
                lines.AppendString(line);
                done = m_delegate.IOHandlerIsInputComplete(*this, lines);
            }
            else
            {
                done = true;
            }
        }
        success = lines.GetSize() > 0;
#ifndef LLDB_DISABLE_LIBEDIT
    }
#endif
    return success;
}

// Each IOHandler gets to run until it is done. It should read data
// from the "in" and place output into "out" and "err and return
// when done.
void
IOHandlerEditline::Run ()
{
    std::string line;
    while (IsActive())
    {
        bool interrupted = false;
        if (m_multi_line)
        {
            StringList lines;
            if (GetLines (lines, interrupted))
            {
                if (interrupted)
                {
                    m_done = m_interrupt_exits;
                    m_delegate.IOHandlerInputInterrupted (*this, line);

                }
                else
                {
                    line = lines.CopyList();
                    m_delegate.IOHandlerInputComplete (*this, line);
                }
            }
            else
            {
                m_done = true;
            }
        }
        else
        {
            if (GetLine(line, interrupted))
            {
                if (interrupted)
                    m_delegate.IOHandlerInputInterrupted (*this, line);
                else
                    m_delegate.IOHandlerInputComplete (*this, line);
            }
            else
            {
                m_done = true;
            }
        }
    }
}

void
IOHandlerEditline::Cancel ()
{
#ifndef LLDB_DISABLE_LIBEDIT
    if (m_editline_ap)
        m_editline_ap->Cancel ();
#endif
}

bool
IOHandlerEditline::Interrupt ()
{
    // Let the delgate handle it first
    if (m_delegate.IOHandlerInterrupt(*this))
        return true;

#ifndef LLDB_DISABLE_LIBEDIT
    if (m_editline_ap)
        return m_editline_ap->Interrupt();
#endif
    return false;
}

void
IOHandlerEditline::GotEOF()
{
#ifndef LLDB_DISABLE_LIBEDIT
    if (m_editline_ap)
        m_editline_ap->Interrupt();
#endif
}

void
IOHandlerEditline::PrintAsync (Stream *stream, const char *s, size_t len)
{
#ifndef LLDB_DISABLE_LIBEDIT
    if (m_editline_ap)
        m_editline_ap->PrintAsync(stream, s, len);
    else
#endif
        IOHandler::PrintAsync(stream, s, len);
}

// we may want curses to be disabled for some builds
// for instance, windows
#ifndef LLDB_DISABLE_CURSES

#include "lldb/Core/ValueObject.h"
#include "lldb/Symbol/VariableList.h"
#include "lldb/Target/Target.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/Thread.h"
#include "lldb/Target/StackFrame.h"

#define KEY_RETURN   10
#define KEY_ESCAPE  27

namespace curses
{
    class Menu;
    class MenuDelegate;
    class Window;
    class WindowDelegate;
    typedef std::shared_ptr<Menu> MenuSP;
    typedef std::shared_ptr<MenuDelegate> MenuDelegateSP;
    typedef std::shared_ptr<Window> WindowSP;
    typedef std::shared_ptr<WindowDelegate> WindowDelegateSP;
    typedef std::vector<MenuSP> Menus;
    typedef std::vector<WindowSP> Windows;
    typedef std::vector<WindowDelegateSP> WindowDelegates;

#if 0
type summary add -s "x=${var.x}, y=${var.y}" curses::Point
type summary add -s "w=${var.width}, h=${var.height}" curses::Size
type summary add -s "${var.origin%S} ${var.size%S}" curses::Rect
#endif

    struct Point
    {
        int x;
        int y;
        
        Point (int _x = 0, int _y = 0) :
            x(_x),
            y(_y)
        {
        }

        void
        Clear ()
        {
            x = 0;
            y = 0;
        }
        
        Point &
        operator += (const Point &rhs)
        {
            x += rhs.x;
            y += rhs.y;
            return *this;
        }
        
        void
        Dump ()
        {
            printf ("(x=%i, y=%i)\n", x, y);
        }
    };
    
    bool operator == (const Point &lhs, const Point &rhs)
    {
        return lhs.x == rhs.x && lhs.y == rhs.y;
    }

    bool operator != (const Point &lhs, const Point &rhs)
    {
        return lhs.x != rhs.x || lhs.y != rhs.y;
    }

    struct Size
    {
        int width;
        int height;
        Size (int w = 0, int h = 0) :
            width (w),
            height (h)
        {
        }
        
        void
        Clear ()
        {
            width = 0;
            height = 0;
        }

        void
        Dump ()
        {
            printf ("(w=%i, h=%i)\n", width, height);
        }
    };
    
    bool operator == (const Size &lhs, const Size &rhs)
    {
        return lhs.width == rhs.width && lhs.height == rhs.height;
    }

    bool operator != (const Size &lhs, const Size &rhs)
    {
        return lhs.width != rhs.width || lhs.height != rhs.height;
    }

    struct Rect
    {
        Point origin;
        Size size;
        
        Rect () :
            origin(),
            size()
        {
        }
    
        Rect (const Point &p, const Size &s) :
            origin (p),
            size (s)
        {
        }
        
        void
        Clear ()
        {
            origin.Clear();
            size.Clear();
        }
        
        void
        Dump ()
        {
            printf ("(x=%i, y=%i), w=%i, h=%i)\n", origin.x, origin.y, size.width, size.height);
        }
        
        void
        Inset (int w, int h)
        {
            if (size.width > w*2)
                size.width -= w*2;
            origin.x += w;

            if (size.height > h*2)
                size.height -= h*2;
            origin.y += h;
        }

        // Return a status bar rectangle which is the last line of
        // this rectangle. This rectangle will be modified to not
        // include the status bar area.
        Rect
        MakeStatusBar ()
        {
            Rect status_bar;
            if (size.height > 1)
            {
                status_bar.origin.x = origin.x;
                status_bar.origin.y = size.height;
                status_bar.size.width = size.width;
                status_bar.size.height = 1;
                --size.height;
            }
            return status_bar;
        }

        // Return a menubar rectangle which is the first line of
        // this rectangle. This rectangle will be modified to not
        // include the menubar area.
        Rect
        MakeMenuBar ()
        {
            Rect menubar;
            if (size.height > 1)
            {
                menubar.origin.x = origin.x;
                menubar.origin.y = origin.y;
                menubar.size.width = size.width;
                menubar.size.height = 1;
                ++origin.y;
                --size.height;
            }
            return menubar;
        }

        void
        HorizontalSplitPercentage (float top_percentage, Rect &top, Rect &bottom) const
        {
            float top_height = top_percentage * size.height;
            HorizontalSplit (top_height, top, bottom);
        }

        void
        HorizontalSplit (int top_height, Rect &top, Rect &bottom) const
        {
            top = *this;
            if (top_height < size.height)
            {
                top.size.height = top_height;
                bottom.origin.x = origin.x;
                bottom.origin.y = origin.y + top.size.height;
                bottom.size.width = size.width;
                bottom.size.height = size.height - top.size.height;
            }
            else
            {
                bottom.Clear();
            }
        }
        
        void
        VerticalSplitPercentage (float left_percentage, Rect &left, Rect &right) const
        {
            float left_width = left_percentage * size.width;
            VerticalSplit (left_width, left, right);
        }

        void
        VerticalSplit (int left_width, Rect &left, Rect &right) const
        {
            left = *this;
            if (left_width < size.width)
            {
                left.size.width = left_width;
                right.origin.x = origin.x + left.size.width;
                right.origin.y = origin.y;
                right.size.width = size.width - left.size.width;
                right.size.height = size.height;
            }
            else
            {
                right.Clear();
            }
        }
    };

    bool operator == (const Rect &lhs, const Rect &rhs)
    {
        return lhs.origin == rhs.origin && lhs.size == rhs.size;
    }

    bool operator != (const Rect &lhs, const Rect &rhs)
    {
        return lhs.origin != rhs.origin || lhs.size != rhs.size;
    }

    enum HandleCharResult
    {
        eKeyNotHandled      = 0,
        eKeyHandled         = 1,
        eQuitApplication    = 2
    };
    
    enum class MenuActionResult
    {
        Handled,
        NotHandled,
        Quit    // Exit all menus and quit
    };

    struct KeyHelp
    {
        int ch;
        const char *description;
    };

    class WindowDelegate
    {
    public:
        virtual
        ~WindowDelegate() = default;

        virtual bool
        WindowDelegateDraw (Window &window, bool force)
        {
            return false; // Drawing not handled
        }
        
        virtual HandleCharResult
        WindowDelegateHandleChar (Window &window, int key)
        {
            return eKeyNotHandled;
        }
        
        virtual const char *
        WindowDelegateGetHelpText ()
        {
            return NULL;
        }

        virtual KeyHelp *
        WindowDelegateGetKeyHelp ()
        {
            return NULL;
        }
    };
    
    class HelpDialogDelegate :
        public WindowDelegate
    {
    public:
        HelpDialogDelegate (const char *text, KeyHelp *key_help_array);

        ~HelpDialogDelegate() override;

        bool
        WindowDelegateDraw (Window &window, bool force) override;
        
        HandleCharResult
        WindowDelegateHandleChar (Window &window, int key) override;
        
        size_t
        GetNumLines() const
        {
            return m_text.GetSize();
        }

        size_t
        GetMaxLineLength () const
        {
            return m_text.GetMaxStringLength();
        }

    protected:
        StringList m_text;
        int m_first_visible_line;
    };

    class Window
    {
    public:
        Window (const char *name) :
            m_name (name),
            m_window (NULL),
            m_panel (NULL),
            m_parent (NULL),
            m_subwindows (),
            m_delegate_sp (),
            m_curr_active_window_idx (UINT32_MAX),
            m_prev_active_window_idx (UINT32_MAX),
            m_delete (false),
            m_needs_update (true),
            m_can_activate (true),
            m_is_subwin (false)
        {
        }
        
        Window (const char *name, WINDOW *w, bool del = true) :
            m_name (name),
            m_window (NULL),
            m_panel (NULL),
            m_parent (NULL),
            m_subwindows (),
            m_delegate_sp (),
            m_curr_active_window_idx (UINT32_MAX),
            m_prev_active_window_idx (UINT32_MAX),
            m_delete (del),
            m_needs_update (true),
            m_can_activate (true),
            m_is_subwin (false)
        {
            if (w)
                Reset(w);
        }
        
        Window (const char *name, const Rect &bounds) :
            m_name (name),
            m_window (NULL),
            m_parent (NULL),
            m_subwindows (),
            m_delegate_sp (),
            m_curr_active_window_idx (UINT32_MAX),
            m_prev_active_window_idx (UINT32_MAX),
            m_delete (true),
            m_needs_update (true),
            m_can_activate (true),
            m_is_subwin (false)
        {
            Reset (::newwin (bounds.size.height, bounds.size.width, bounds.origin.y, bounds.origin.y));
        }
        
        virtual
        ~Window ()
        {
            RemoveSubWindows ();
            Reset ();
        }
        
        void
        Reset (WINDOW *w = NULL, bool del = true)
        {
            if (m_window == w)
                return;
            
            if (m_panel)
            {
                ::del_panel (m_panel);
                m_panel = NULL;
            }
            if (m_window && m_delete)
            {
                ::delwin (m_window);
                m_window = NULL;
                m_delete = false;
            }
            if (w)
            {
                m_window = w;
                m_panel = ::new_panel (m_window);
                m_delete = del;
            }
        }
        
        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    Clear ()    { ::wclear (m_window); }
        void    Erase ()    { ::werase (m_window); }
        Rect    GetBounds () { return Rect (GetParentOrigin(), GetSize()); } // Get the rectangle in our parent window
        int     GetChar ()  { return ::wgetch (m_window); }
        int     GetCursorX ()     { return getcurx (m_window); }
        int     GetCursorY ()     { return getcury (m_window); }
        Rect    GetFrame ()    { return Rect (Point(), GetSize()); } // Get our rectangle in our own coordinate system
        Point   GetParentOrigin() { return Point (GetParentX(), GetParentY()); }
        Size    GetSize()         { return Size (GetWidth(), GetHeight()); }
        int     GetParentX ()     { return getparx (m_window); }
        int     GetParentY ()     { return getpary (m_window); }
        int     GetMaxX()   { return getmaxx (m_window); }
        int     GetMaxY()   { return getmaxy (m_window); }
        int     GetWidth()  { return GetMaxX(); }
        int     GetHeight() { return GetMaxY(); }
        void    MoveCursor (int x, int y) {  ::wmove (m_window, y, x); }
        void    MoveWindow (int x, int y) {  MoveWindow(Point(x,y)); }
        void    Resize (int w, int h) { ::wresize(m_window, h, w); }
        void    Resize (const Size &size) { ::wresize(m_window, size.height, size.width); }
        void    PutChar (int ch)    { ::waddch (m_window, ch); }
        void    PutCString (const char *s, int len = -1) { ::waddnstr (m_window, s, len); }
        void    Refresh ()  { ::wrefresh (m_window); }
        void    DeferredRefresh ()
        {
            // We are using panels, so we don't need to call this...
            //::wnoutrefresh(m_window);
        }
        void    SetBackground (int color_pair_idx) { ::wbkgd (m_window,COLOR_PAIR(color_pair_idx)); }
        void    UnderlineOn ()  { AttributeOn(A_UNDERLINE); }
        void    UnderlineOff () { AttributeOff(A_UNDERLINE); }

        void    PutCStringTruncated (const char *s, int right_pad)
        {
            int bytes_left = GetWidth() - GetCursorX();
            if (bytes_left > right_pad)
            {
                bytes_left -= right_pad;
                ::waddnstr (m_window, s, bytes_left);
            }
        }

        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);
            }
            else
            {
                ::mvwin (m_window, origin.y, origin.x);
            }
        }

        void
        SetBounds (const Rect &bounds)
        {
            const bool moving_window = bounds.origin != GetParentOrigin();
            if (m_is_subwin && moving_window)
            {
                // Can't move subwindows, must delete and re-create
                Reset (::subwin (m_parent->m_window,
                                 bounds.size.height,
                                 bounds.size.width,
                                 bounds.origin.y,
                                 bounds.origin.x), true);
            }
            else
            {
                if (moving_window)
                    MoveWindow(bounds.origin);
                Resize (bounds.size);
            }
        }

        void
        Printf (const char *format, ...)  __attribute__ ((format (printf, 2, 3)))
        {
            va_list args;
            va_start (args, format);
            vwprintw(m_window, format, args);
            va_end (args);
        }

        void
        Touch ()
        {
            ::touchwin (m_window);
            if (m_parent)
                m_parent->Touch();
        }

        WindowSP
        CreateSubWindow (const char *name, const Rect &bounds, bool make_active)
        {
            WindowSP subwindow_sp;
            if (m_window)
            {
                subwindow_sp.reset(new Window(name, ::subwin (m_window,
                                                              bounds.size.height,
                                                              bounds.size.width,
                                                              bounds.origin.y,
                                                              bounds.origin.x), true));
                subwindow_sp->m_is_subwin = true;
            }
            else
            {
                subwindow_sp.reset(new Window(name, ::newwin (bounds.size.height,
                                                              bounds.size.width,
                                                              bounds.origin.y,
                                                              bounds.origin.x), true));
                subwindow_sp->m_is_subwin = false;
            }
            subwindow_sp->m_parent = this;
            if (make_active)
            {
                m_prev_active_window_idx = m_curr_active_window_idx;
                m_curr_active_window_idx = m_subwindows.size();
            }
            m_subwindows.push_back(subwindow_sp);
            ::top_panel (subwindow_sp->m_panel);
            m_needs_update = true;
            return subwindow_sp;
        }
        
        bool
        RemoveSubWindow (Window *window)
        {
            Windows::iterator pos, end = m_subwindows.end();
            size_t i = 0;
            for (pos = m_subwindows.begin(); pos != end; ++pos, ++i)
            {
                if ((*pos).get() == window)
                {
                    if (m_prev_active_window_idx == i)
                        m_prev_active_window_idx = UINT32_MAX;
                    else if (m_prev_active_window_idx != UINT32_MAX && m_prev_active_window_idx > i)
                        --m_prev_active_window_idx;

                    if (m_curr_active_window_idx == i)
                        m_curr_active_window_idx = UINT32_MAX;
                    else if (m_curr_active_window_idx != UINT32_MAX && m_curr_active_window_idx > i)
                        --m_curr_active_window_idx;
                    window->Erase();
                    m_subwindows.erase(pos);
                    m_needs_update = true;
                    if (m_parent)
                        m_parent->Touch();
                    else
                        ::touchwin (stdscr);
                    return true;
                }
            }
            return false;
        }
        
        WindowSP
        FindSubWindow (const char *name)
        {
            Windows::iterator pos, end = m_subwindows.end();
            size_t i = 0;
            for (pos = m_subwindows.begin(); pos != end; ++pos, ++i)
            {
                if ((*pos)->m_name.compare(name) == 0)
                    return *pos;
            }
            return WindowSP();
        }
        
        void
        RemoveSubWindows ()
        {
            m_curr_active_window_idx = UINT32_MAX;
            m_prev_active_window_idx = UINT32_MAX;
            for (Windows::iterator pos = m_subwindows.begin();
                 pos != m_subwindows.end();
                 pos = m_subwindows.erase(pos))
            {
                (*pos)->Erase();
            }
            if (m_parent)
                m_parent->Touch();
            else
                ::touchwin (stdscr);
        }

        WINDOW *
        get()
        {
            return m_window;
        }

        operator WINDOW *()
        {
            return m_window;
        }
        
        //----------------------------------------------------------------------
        // Window drawing utilities
        //----------------------------------------------------------------------
        void
        DrawTitleBox (const char *title, const char *bottom_message = NULL)
        {
            attr_t attr = 0;
            if (IsActive())
                attr = A_BOLD | COLOR_PAIR(2);
            else
                attr = 0;
            if (attr)
                AttributeOn(attr);

            Box();
            MoveCursor(3, 0);
            
            if (title && title[0])
            {
                PutChar ('<');
                PutCString (title);
                PutChar ('>');
            }
            
            if (bottom_message && bottom_message[0])
            {
                int bottom_message_length = strlen(bottom_message);
                int x = GetWidth() - 3 - (bottom_message_length + 2);
                
                if (x > 0)
                {
                    MoveCursor (x, GetHeight() - 1);
                    PutChar ('[');
                    PutCString(bottom_message);
                    PutChar (']');
                }
                else
                {
                    MoveCursor (1, GetHeight() - 1);
                    PutChar ('[');
                    PutCStringTruncated (bottom_message, 1);
                }
            }
            if (attr)
                AttributeOff(attr);
            
        }

        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);
        }

        bool
        CreateHelpSubwindow ()
        {
            if (m_delegate_sp)
            {
                const char *text = m_delegate_sp->WindowDelegateGetHelpText ();
                KeyHelp *key_help = m_delegate_sp->WindowDelegateGetKeyHelp ();
                if ((text && text[0]) || key_help)
                {
                    std::auto_ptr<HelpDialogDelegate> help_delegate_ap(new HelpDialogDelegate(text, key_help));
                    const size_t num_lines = help_delegate_ap->GetNumLines();
                    const size_t max_length = help_delegate_ap->GetMaxLineLength();
                    Rect bounds = GetBounds();
                    bounds.Inset(1, 1);
                    if (max_length + 4 < static_cast<size_t>(bounds.size.width))
                    {
                        bounds.origin.x += (bounds.size.width - max_length + 4)/2;
                        bounds.size.width = max_length + 4;
                    }
                    else
                    {
                        if (bounds.size.width > 100)
                        {
                            const int inset_w = bounds.size.width / 4;
                            bounds.origin.x += inset_w;
                            bounds.size.width -= 2*inset_w;
                        }
                    }
                    
                    if (num_lines + 2 < static_cast<size_t>(bounds.size.height))
                    {
                        bounds.origin.y += (bounds.size.height - num_lines + 2)/2;
                        bounds.size.height = num_lines + 2;
                    }
                    else
                    {
                        if (bounds.size.height > 100)
                        {
                            const int inset_h = bounds.size.height / 4;
                            bounds.origin.y += inset_h;
                            bounds.size.height -= 2*inset_h;
                        }
                    }
                    WindowSP help_window_sp;
                    Window *parent_window = GetParent();
                    if (parent_window)
                        help_window_sp = parent_window->CreateSubWindow("Help", bounds, true);
                    else
                        help_window_sp = CreateSubWindow("Help", bounds, true);
                    help_window_sp->SetDelegate(WindowDelegateSP(help_delegate_ap.release()));
                    return true;
                }
            }
            return false;
        }

        virtual HandleCharResult
        HandleChar (int key)
        {
            // Always check the active window first
            HandleCharResult result = eKeyNotHandled;
            WindowSP active_window_sp = GetActiveWindow ();
            if (active_window_sp)
            {
                result = active_window_sp->HandleChar (key);
                if (result != eKeyNotHandled)
                    return result;
            }
            
            if (m_delegate_sp)
            {
                result = m_delegate_sp->WindowDelegateHandleChar (*this, key);
                if (result != eKeyNotHandled)
                    return result;
            }

            // Then check for any windows that want any keys
            // that weren't handled. This is typically only
            // for a menubar.
            // Make a copy of the subwindows in case any HandleChar()
            // functions muck with the subwindows. If we don't do this,
            // we can crash when iterating over the subwindows.
            Windows subwindows (m_subwindows);
            for (auto subwindow_sp : subwindows)
            {
                if (subwindow_sp->m_can_activate == false)
                {
                    HandleCharResult result = subwindow_sp->HandleChar(key);
                    if (result != eKeyNotHandled)
                        return result;
                }
            }

            return eKeyNotHandled;
        }

        bool
        SetActiveWindow (Window *window)
        {
            const size_t num_subwindows = m_subwindows.size();
            for (size_t i=0; i<num_subwindows; ++i)
            {
                if (m_subwindows[i].get() == window)
                {
                    m_prev_active_window_idx = m_curr_active_window_idx;
                    ::top_panel (window->m_panel);
                    m_curr_active_window_idx = i;
                    return true;
                }
            }
            return false;
        }

        WindowSP
        GetActiveWindow ()
        {
            if (!m_subwindows.empty())
            {
                if (m_curr_active_window_idx >= m_subwindows.size())
                {
                    if (m_prev_active_window_idx < m_subwindows.size())
                    {
                        m_curr_active_window_idx = m_prev_active_window_idx;
                        m_prev_active_window_idx = UINT32_MAX;
                    }
                    else if (IsActive())
                    {
                        m_prev_active_window_idx = UINT32_MAX;
                        m_curr_active_window_idx = UINT32_MAX;
                        
                        // Find first window that wants to be active if this window is active
                        const size_t num_subwindows = m_subwindows.size();
                        for (size_t i=0; i<num_subwindows; ++i)
                        {
                            if (m_subwindows[i]->GetCanBeActive())
                            {
                                m_curr_active_window_idx = i;
                                break;
                            }
                        }
                    }
                }
                
                if (m_curr_active_window_idx < m_subwindows.size())
                    return m_subwindows[m_curr_active_window_idx];
            }
            return WindowSP();
        }
        
        bool
        GetCanBeActive () const
        {
            return m_can_activate;
        }

        void
        SetCanBeActive (bool b)
        {
            m_can_activate = b;
        }
        
        const WindowDelegateSP &
        GetDelegate () const
        {
            return m_delegate_sp;
        }

        void
        SetDelegate (const WindowDelegateSP &delegate_sp)
        {
            m_delegate_sp = delegate_sp;
        }
        
        Window *
        GetParent () const
        {
            return m_parent;
        }
        
        bool
        IsActive () const
        {
            if (m_parent)
                return m_parent->GetActiveWindow().get() == this;
            else
                return true; // Top level window is always active
        }
        
        void
        SelectNextWindowAsActive ()
        {
            // Move active focus to next window
            const size_t num_subwindows = m_subwindows.size();
            if (m_curr_active_window_idx == UINT32_MAX)
            {
                uint32_t idx = 0;
                for (auto subwindow_sp : m_subwindows)
                {
                    if (subwindow_sp->GetCanBeActive())
                    {
                        m_curr_active_window_idx = idx;
                        break;
                    }
                    ++idx;
                }
            }
            else if (m_curr_active_window_idx + 1 < num_subwindows)
            {
                bool handled = false;
                m_prev_active_window_idx = m_curr_active_window_idx;
                for (size_t idx=m_curr_active_window_idx + 1; idx<num_subwindows; ++idx)
                {
                    if (m_subwindows[idx]->GetCanBeActive())
                    {
                        m_curr_active_window_idx = idx;
                        handled = true;
                        break;
                    }
                }
                if (!handled)
                {
                    for (size_t idx=0; idx<=m_prev_active_window_idx; ++idx)
                    {
                        if (m_subwindows[idx]->GetCanBeActive())
                        {
                            m_curr_active_window_idx = idx;
                            break;
                        }
                    }
                }
            }
            else
            {
                m_prev_active_window_idx = m_curr_active_window_idx;
                for (size_t idx=0; idx<num_subwindows; ++idx)
                {
                    if (m_subwindows[idx]->GetCanBeActive())
                    {
                        m_curr_active_window_idx = idx;
                        break;
                    }
                }
            }
        }

        const char *
        GetName () const
        {
            return m_name.c_str();
        }

    protected:
        std::string m_name;
        WINDOW *m_window;
        PANEL *m_panel;
        Window *m_parent;
        Windows m_subwindows;
        WindowDelegateSP m_delegate_sp;
        uint32_t m_curr_active_window_idx;
        uint32_t m_prev_active_window_idx;
        bool m_delete;
        bool m_needs_update;
        bool m_can_activate;
        bool m_is_subwin;
        
    private:
        DISALLOW_COPY_AND_ASSIGN(Window);
    };
    
    class MenuDelegate
    {
    public:
        virtual ~MenuDelegate() = default;

        virtual MenuActionResult
        MenuDelegateAction (Menu &menu) = 0;
    };

    class Menu : public WindowDelegate
    {
    public:
        enum class Type
        {
            Invalid,
            Bar,
            Item,
            Separator
        };
        
        // Menubar or separator constructor
        Menu (Type type);
        
        // Menuitem constructor
        Menu (const char *name,
              const char *key_name,
              int key_value,
              uint64_t identifier);

        ~Menu() override = default;

        const MenuDelegateSP &
        GetDelegate () const
        {
            return m_delegate_sp;
        }
        
        void
        SetDelegate (const MenuDelegateSP &delegate_sp)
        {
            m_delegate_sp = delegate_sp;
        }
        
        void
        RecalculateNameLengths();

        void
        AddSubmenu (const MenuSP &menu_sp);
        
        int
        DrawAndRunMenu (Window &window);
        
        void
        DrawMenuTitle (Window &window, bool highlight);

        bool
        WindowDelegateDraw (Window &window, bool force) override;
        
        HandleCharResult
        WindowDelegateHandleChar (Window &window, int key) override;

        MenuActionResult
        ActionPrivate (Menu &menu)
        {
            MenuActionResult result = MenuActionResult::NotHandled;
            if (m_delegate_sp)
            {
                result = m_delegate_sp->MenuDelegateAction (menu);
                if (result != MenuActionResult::NotHandled)
                    return result;
            }
            else if (m_parent)
            {
                result = m_parent->ActionPrivate(menu);
                if (result != MenuActionResult::NotHandled)
                    return result;
            }
            return m_canned_result;
        }

        MenuActionResult
        Action ()
        {
            // Call the recursive action so it can try to handle it
            // with the menu delegate, and if not, try our parent menu
            return ActionPrivate (*this);
        }
        
        void
        SetCannedResult (MenuActionResult result)
        {
            m_canned_result = result;
        }

        Menus &
        GetSubmenus()
        {
            return m_submenus;
        }

        const Menus &
        GetSubmenus() const
        {
            return m_submenus;
        }

        int
        GetSelectedSubmenuIndex () const
        {
            return m_selected;
        }
        
        void
        SetSelectedSubmenuIndex (int idx)
        {
            m_selected = idx;
        }

        Type
        GetType () const
        {
            return m_type;
        }
        
        int
        GetStartingColumn() const
        {
            return m_start_col;
        }

        void
        SetStartingColumn(int col)
        {
            m_start_col = col;
        }

        int
        GetKeyValue() const
        {
            return m_key_value;
        }
        
        void
        SetKeyValue(int key_value)
        {
            m_key_value = key_value;
        }

        std::string &
        GetName()
        {
            return m_name;
        }

        std::string &
        GetKeyName()
        {
            return m_key_name;
        }

        int
        GetDrawWidth () const
        {
            return m_max_submenu_name_length + m_max_submenu_key_name_length + 8;
        }

        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;
        Type m_type;
        int m_key_value;
        int m_start_col;
        int m_max_submenu_name_length;
        int m_max_submenu_key_name_length;
        int m_selected;
        Menu *m_parent;
        Menus m_submenus;
        WindowSP m_menu_window_sp;
        MenuActionResult m_canned_result;
        MenuDelegateSP m_delegate_sp;
    };

    // Menubar or separator constructor
    Menu::Menu (Type type) :
        m_name (),
        m_key_name (),
        m_identifier (0),
        m_type (type),
        m_key_value (0),
        m_start_col (0),
        m_max_submenu_name_length (0),
        m_max_submenu_key_name_length (0),
        m_selected (0),
        m_parent (NULL),
        m_submenus (),
        m_canned_result (MenuActionResult::NotHandled),
        m_delegate_sp()
    {
    }

    // Menuitem constructor
    Menu::Menu (const char *name,
                const char *key_name,
                int key_value,
                uint64_t identifier) :
        m_name (),
        m_key_name (),
        m_identifier (identifier),
        m_type (Type::Invalid),
        m_key_value (key_value),
        m_start_col (0),
        m_max_submenu_name_length (0),
        m_max_submenu_key_name_length (0),
        m_selected (0),
        m_parent (NULL),
        m_submenus (),
        m_canned_result (MenuActionResult::NotHandled),
        m_delegate_sp()
    {
        if (name && name[0])
        {
            m_name = name;
            m_type = Type::Item;
            if (key_name && key_name[0])
                m_key_name = key_name;
        }
        else
        {
            m_type = Type::Separator;
        }
    }

    void
    Menu::RecalculateNameLengths()
    {
        m_max_submenu_name_length = 0;
        m_max_submenu_key_name_length = 0;
        Menus &submenus = GetSubmenus();
        const size_t num_submenus = submenus.size();
        for (size_t i=0; i<num_submenus; ++i)
        {
            Menu *submenu = submenus[i].get();
            if (static_cast<size_t>(m_max_submenu_name_length) < submenu->m_name.size())
                m_max_submenu_name_length = submenu->m_name.size();
            if (static_cast<size_t>(m_max_submenu_key_name_length) < submenu->m_key_name.size())
                m_max_submenu_key_name_length = submenu->m_key_name.size();
        }
    }

    void
    Menu::AddSubmenu (const MenuSP &menu_sp)
    {
        menu_sp->m_parent = this;
        if (static_cast<size_t>(m_max_submenu_name_length) < menu_sp->m_name.size())
            m_max_submenu_name_length = menu_sp->m_name.size();
        if (static_cast<size_t>(m_max_submenu_key_name_length) < menu_sp->m_key_name.size())
            m_max_submenu_key_name_length = menu_sp->m_key_name.size();
        m_submenus.push_back(menu_sp);
    }

    void
    Menu::DrawMenuTitle (Window &window, bool highlight)
    {
        if (m_type == Type::Separator)
        {
            window.MoveCursor(0, window.GetCursorY());
            window.PutChar(ACS_LTEE);
            int width = window.GetWidth();
            if (width > 2)
            {
                width -= 2;
                for (int i=0; i< width; ++i)
                    window.PutChar(ACS_HLINE);
            }
            window.PutChar(ACS_RTEE);
        }
        else
        {
            const int shortcut_key = m_key_value;
            bool underlined_shortcut = false;
            const attr_t hilgight_attr = A_REVERSE;
            if (highlight)
                window.AttributeOn(hilgight_attr);
            if (isprint(shortcut_key))
            {
                size_t lower_pos = m_name.find(tolower(shortcut_key));
                size_t upper_pos = m_name.find(toupper(shortcut_key));
                const char *name = m_name.c_str();
                size_t pos = std::min<size_t>(lower_pos, upper_pos);
                if (pos != std::string::npos)
                {
                    underlined_shortcut = true;
                    if (pos > 0)
                    {
                        window.PutCString(name, pos);
                        name += pos;
                    }
                    const attr_t shortcut_attr = A_UNDERLINE|A_BOLD;
                    window.AttributeOn (shortcut_attr);
                    window.PutChar(name[0]);
                    window.AttributeOff(shortcut_attr);
                    name++;
                    if (name[0])
                        window.PutCString(name);
                }
            }
            
            if (!underlined_shortcut)
            {
                window.PutCString(m_name.c_str());
            }

            if (highlight)
                window.AttributeOff(hilgight_attr);

            if (m_key_name.empty())
            {
                if (!underlined_shortcut && isprint(m_key_value))
                {
                    window.AttributeOn (COLOR_PAIR(3));
                    window.Printf (" (%c)", m_key_value);
                    window.AttributeOff (COLOR_PAIR(3));
                }
            }
            else
            {
                window.AttributeOn (COLOR_PAIR(3));
                window.Printf (" (%s)", m_key_name.c_str());
                window.AttributeOff (COLOR_PAIR(3));
            }
        }
    }
    
    bool
    Menu::WindowDelegateDraw (Window &window, bool force)
    {
        Menus &submenus = GetSubmenus();
        const size_t num_submenus = submenus.size();
        const int selected_idx = GetSelectedSubmenuIndex();
        Menu::Type menu_type = GetType ();
        switch (menu_type)
        {
        case  Menu::Type::Bar:
            {
                window.SetBackground(2);
                window.MoveCursor(0, 0);
                for (size_t i=0; i<num_submenus; ++i)
                {
                    Menu *menu = submenus[i].get();
                    if (i > 0)
                        window.PutChar(' ');
                    menu->SetStartingColumn (window.GetCursorX());
                    window.PutCString("| ");
                    menu->DrawMenuTitle (window, false);
                }
                window.PutCString(" |");
                window.DeferredRefresh();
            }
            break;
                
        case Menu::Type::Item:
            {
                int y = 1;
                int x = 3;
                // Draw the menu
                int cursor_x = 0;
                int cursor_y = 0;
                window.Erase();
                window.SetBackground(2);
                window.Box();
                for (size_t i=0; i<num_submenus; ++i)
                {
                    const bool is_selected =
                      (i == static_cast<size_t>(selected_idx));
                    window.MoveCursor(x, y + i);
                    if (is_selected)
                    {
                        // Remember where we want the cursor to be
                        cursor_x = x-1;
                        cursor_y = y+i;
                    }
                    submenus[i]->DrawMenuTitle (window, is_selected);
                }
                window.MoveCursor(cursor_x, cursor_y);
                window.DeferredRefresh();
            }
            break;

        default:
        case Menu::Type::Separator:
            break;
        }
        return true; // Drawing handled...
    }
    
    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();
        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))
                        run_menu_sp = submenus[selected_idx];
                    else if (!submenus.empty())
                        run_menu_sp = submenus.front();
                    result = eKeyHandled;
                    break;
                    
                case KEY_RIGHT:
                {
                    ++m_selected;
                    if (m_selected >= static_cast<int>(num_submenus))
                        m_selected = 0;
                    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_LEFT:
                {
                    --m_selected;
                    if (m_selected < 0)
                        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;
                    
                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;
                        }
                    }
                    break;
            }
            
            if (run_menu_sp)
            {
                // Run the action on this menu in case we need to populate the
                // menu with dynamic content and also in case check marks, and
                // any other menu decorations need to be calculated
                if (run_menu_sp->Action() == MenuActionResult::Quit)
                    return eQuitApplication;

                Rect menu_bounds;
                menu_bounds.origin.x = run_menu_sp->GetStartingColumn();
                menu_bounds.origin.y = 1;
                menu_bounds.size.width = run_menu_sp->GetDrawWidth();
                menu_bounds.size.height = run_menu_sp->GetSubmenus().size() + 2;
                if (m_menu_window_sp)
                    window.GetParent()->RemoveSubWindow(m_menu_window_sp.get());
                
                m_menu_window_sp = window.GetParent()->CreateSubWindow (run_menu_sp->GetName().c_str(),
                                                                        menu_bounds,
                                                                        true);
                m_menu_window_sp->SetDelegate (run_menu_sp);
            }
        }
        else if (menu_type == Menu::Type::Item)
        {
            switch (key)
            {
                case KEY_DOWN:
                    if (m_submenus.size() > 1)
                    {
                        const int start_select = m_selected;
                        while (++m_selected != start_select)
                        {
                            if (static_cast<size_t>(m_selected) >= num_submenus)
                                m_selected = 0;
                            if (m_submenus[m_selected]->GetType() == Type::Separator)
                                continue;
                            else
                                break;
                        }
                        return eKeyHandled;
                    }
                    break;
                    
                case KEY_UP:
                    if (m_submenus.size() > 1)
                    {
                        const int start_select = m_selected;
                        while (--m_selected != start_select)
                        {
                            if (m_selected < static_cast<int>(0))
                                m_selected = num_submenus - 1;
                            if (m_submenus[m_selected]->GetType() == Type::Separator)
                                continue;
                            else
                                break;
                        }
                        return eKeyHandled;
                    }
                    break;
                    
                case KEY_RETURN:
                    if (static_cast<size_t>(selected_idx) < num_submenus)
                    {
                        if (submenus[selected_idx]->Action() == MenuActionResult::Quit)
                            return eQuitApplication;
                        window.GetParent()->RemoveSubWindow(&window);
                        return eKeyHandled;
                    }
                    break;
                    
                case KEY_ESCAPE: // Beware: pressing escape key has 1 to 2 second delay in case other chars are entered for escaped sequences
                    window.GetParent()->RemoveSubWindow(&window);
                    return eKeyHandled;
                    
                default:
                {
                    for (size_t i=0; i<num_submenus; ++i)
                    {
                        Menu *menu = submenus[i].get();
                        if (menu->GetKeyValue() == key)
                        {
                            SetSelectedSubmenuIndex(i);
                            window.GetParent()->RemoveSubWindow(&window);
                            if (menu->Action() == MenuActionResult::Quit)
                                return eQuitApplication;
                            return eKeyHandled;
                        }
                    }
                }
                    break;
                    
            }
        }
        else if (menu_type == Menu::Type::Separator)
        {
        }
        return result;
    }

    class Application
    {
    public:
        Application (FILE *in, FILE *out) :
            m_window_sp(),
            m_screen (NULL),
            m_in (in),
            m_out (out)
        {
            
        }
        
        ~Application ()
        {
            m_window_delegates.clear();
            m_window_sp.reset();
            if (m_screen)
            {
                ::delscreen(m_screen);
                m_screen = NULL;
            }
        }
        
        void
        Initialize ()
        {
            ::setlocale(LC_ALL, "");
            ::setlocale(LC_CTYPE, "");
#if 0
            ::initscr();
#else
            m_screen = ::newterm(NULL, m_out, m_in);
#endif
            ::start_color();
            ::curs_set(0);
            ::noecho();
            ::keypad(stdscr,TRUE);
        }
        
        void
        Terminate ()
        {
            ::endwin();
        }
        
        void
        Run (Debugger &debugger)
        {
            bool done = false;
            int delay_in_tenths_of_a_second = 1;
            
            // Alas the threading model in curses is a bit lame so we need to
            // resort to polling every 0.5 seconds. We could poll for stdin
            // ourselves and then 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()

            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;
#if defined(__APPLE__)
            std::deque<int> escape_chars;
#endif
            
            while (!done)
            {
                if (update)
                {
                    m_window_sp->Draw(false);
                    // All windows should be calling Window::DeferredRefresh() instead
                    // of Window::Refresh() so we can do a single update and avoid
                    // any screen blinking
                    update_panels();

                    // Cursor hiding isn't working on MacOSX, so hide it in the top left corner
                    m_window_sp->MoveCursor(0, 0);

                    doupdate();
                    update = false;
                }
                
#if defined(__APPLE__)
                // Terminal.app doesn't map its function keys correctly, F1-F4 default to:
                // \033OP, \033OQ, \033OR, \033OS, so lets take care of this here if possible
                int ch;
                if (escape_chars.empty())
                    ch = m_window_sp->GetChar();
                else
                {
                    ch = escape_chars.front();
                    escape_chars.pop_front();
                }
                if (ch == KEY_ESCAPE)
                {
                    int ch2 = m_window_sp->GetChar();
                    if (ch2 == 'O')
                    {
                        int ch3 = m_window_sp->GetChar();
                        switch (ch3)
                        {
                            case 'P': ch = KEY_F(1); break;
                            case 'Q': ch = KEY_F(2); break;
                            case 'R': ch = KEY_F(3); break;
                            case 'S': ch = KEY_F(4); break;
                            default:
                                escape_chars.push_back(ch2);
                                if (ch3 != -1)
                                    escape_chars.push_back(ch3);
                                break;
                        }
                    }
                    else if (ch2 != -1)
                        escape_chars.push_back(ch2);
                }
#else
                int ch = m_window_sp->GetChar();

#endif
                if (ch == -1)
                {
                    if (feof(m_in) || ferror(m_in))
                    {
                        done = true;
                    }
                    else
                    {
                        // Just a timeout from using halfdelay(), check for events
                        EventSP event_sp;
                        while (listener_sp->PeekAtNextEvent())
                        {
                            listener_sp->GetNextEvent(event_sp);
                            
                            if (event_sp)
                            {
                                Broadcaster *broadcaster = event_sp->GetBroadcaster();
                                if (broadcaster)
                                {
                                    //uint32_t event_type = event_sp->GetType();
                                    ConstString broadcaster_class (broadcaster->GetBroadcasterClass());
                                    if (broadcaster_class == broadcaster_class_process)
                                    {
                                        debugger.GetCommandInterpreter().UpdateExecutionContext(NULL);
                                        update = true;
                                        continue; // Don't get any key, just update our view
                                    }
                                }
                            }
                        }
                    }
                }
                else
                {
                    HandleCharResult key_result = m_window_sp->HandleChar(ch);
                    switch (key_result)
                    {
                        case eKeyHandled:
                            debugger.GetCommandInterpreter().UpdateExecutionContext(NULL);
                            update = true;
                            break;
                        case eKeyNotHandled:
                            break;
                        case eQuitApplication:
                            done = true;
                            break;
                    }
                }
            }
            
            debugger.CancelForwardEvents (listener_sp);
        }
        
        WindowSP &
        GetMainWindow ()
        {
            if (!m_window_sp)
                m_window_sp.reset (new Window ("main", stdscr, false));
            return m_window_sp;
        }
        
        WindowDelegates &
        GetWindowDelegates ()
        {
            return m_window_delegates;
        }

    protected:
        WindowSP m_window_sp;
        WindowDelegates m_window_delegates;
        SCREEN *m_screen;
        FILE *m_in;
        FILE *m_out;
    };

} // namespace curses

using namespace curses;

struct Row
{
    ValueObjectSP valobj;
    Row *parent;
    int row_idx;
    int x;
    int y;
    bool might_have_children;
    bool expanded;
    bool calculated_children;
    std::vector<Row> children;
    
    Row (const ValueObjectSP &v, Row *p) :
    valobj (v),
    parent (p),
    row_idx(0),
    x(1),
    y(1),
    might_have_children (v ? v->MightHaveChildren() : false),
    expanded (false),
    calculated_children (false),
    children()
    {
    }
    
    size_t
    GetDepth () const
    {
        if (parent)
            return 1 + parent->GetDepth();
        return 0;
    }
    
    void
    Expand()
    {
        expanded = true;
        if (!calculated_children)
        {
            calculated_children = true;
            if (valobj)
            {
                const size_t num_children = valobj->GetNumChildren();
                for (size_t i=0; i<num_children; ++i)
                {
                    children.push_back(Row (valobj->GetChildAtIndex(i, true), this));
                }
            }
        }
    }
    
    void
    Unexpand ()
    {
        expanded = false;
    }
    
    void
    DrawTree (Window &window)
    {
        if (parent)
            parent->DrawTreeForChild (window, this, 0);
        
        if (might_have_children)
        {
            // It we can get UTF8 characters to work we should try to use the "symbol"
            // UTF8 string below
//            const char *symbol = "";
//            if (row.expanded)
//                symbol = "\xe2\x96\xbd ";
//            else
//                symbol = "\xe2\x96\xb7 ";
//            window.PutCString (symbol);
            
            // The ACS_DARROW and ACS_RARROW don't look very nice they are just a
            // 'v' or '>' character...
//            if (expanded)
//                window.PutChar (ACS_DARROW);
//            else
//                window.PutChar (ACS_RARROW);
            // Since we can't find any good looking right arrow/down arrow
            // symbols, just use a diamond...
            window.PutChar (ACS_DIAMOND);
            window.PutChar (ACS_HLINE);
        }
    }

    void
    DrawTreeForChild (Window &window, Row *child, uint32_t reverse_depth)
    {
        if (parent)
            parent->DrawTreeForChild (window, this, reverse_depth + 1);
        
        if (&children.back() == child)
        {
            // Last child
            if (reverse_depth == 0)
            {
                window.PutChar (ACS_LLCORNER);
                window.PutChar (ACS_HLINE);
            }
            else
            {
                window.PutChar (' ');
                window.PutChar (' ');
            }
        }
        else
        {
            if (reverse_depth == 0)
            {
                window.PutChar (ACS_LTEE);
                window.PutChar (ACS_HLINE);
            }
            else
            {
                window.PutChar (ACS_VLINE);
                window.PutChar (' ');
            }
        }
    }
};

struct DisplayOptions
{
    bool show_types;
};

class TreeItem;

class TreeDelegate
{
public:
    TreeDelegate() {}
    virtual ~TreeDelegate() = default;

    virtual void TreeDelegateDrawTreeItem (TreeItem &item, Window &window) = 0;
    virtual void TreeDelegateGenerateChildren (TreeItem &item) = 0;
    virtual bool TreeDelegateItemSelected (TreeItem &item) = 0; // Return true if we need to update views
};

typedef std::shared_ptr<TreeDelegate> TreeDelegateSP;

class TreeItem
{
public:
    
    TreeItem (TreeItem *parent, TreeDelegate &delegate, bool might_have_children) :
        m_parent (parent),
        m_delegate (delegate),
        m_user_data (NULL),
        m_identifier (0),
        m_row_idx (-1),
        m_children (),
        m_might_have_children (might_have_children),
        m_is_expanded (false)
    {
    }

    TreeItem &
    operator=(const TreeItem &rhs)
    {
        if (this != &rhs)
        {
            m_parent = rhs.m_parent;
            m_delegate = rhs.m_delegate;
            m_user_data = rhs.m_user_data;
            m_identifier = rhs.m_identifier;
            m_row_idx = rhs.m_row_idx;
            m_children = rhs.m_children;
            m_might_have_children = rhs.m_might_have_children;
            m_is_expanded = rhs.m_is_expanded;
        }
        return *this;
    }

    size_t
    GetDepth () const
    {
        if (m_parent)
            return 1 + m_parent->GetDepth();
        return 0;
    }
    
    int
    GetRowIndex () const
    {
        return m_row_idx;
    }

    void
    ClearChildren ()
    {
        m_children.clear();
    }

    void
    Resize (size_t n, const TreeItem &t)
    {
        m_children.resize(n, t);
    }
    
    TreeItem &
    operator [](size_t i)
    {
        return m_children[i];
    }

    void
    SetRowIndex (int row_idx)
    {
        m_row_idx = row_idx;
    }

    size_t
    GetNumChildren ()
    {
        m_delegate.TreeDelegateGenerateChildren (*this);
        return m_children.size();
    }

    void
    ItemWasSelected ()
    {
        m_delegate.TreeDelegateItemSelected(*this);
    }

    void
    CalculateRowIndexes (int &row_idx)
    {
        SetRowIndex(row_idx);
        ++row_idx;

        const bool expanded = IsExpanded();

        // The root item must calculate its children,
        // or we must calculate the number of children
        // if the item is expanded
        if (m_parent == NULL || expanded)
            GetNumChildren();
        
        for (auto &item : m_children)
        {
            if (expanded)
                item.CalculateRowIndexes(row_idx);
            else
                item.SetRowIndex(-1);
        }
    }

    TreeItem *
    GetParent ()
    {
        return m_parent;
    }

    bool
    IsExpanded () const
    {
        return m_is_expanded;
    }

    void
    Expand()
    {
        m_is_expanded = true;
    }
    
    void
    Unexpand ()
    {
        m_is_expanded = false;
    }
    
    bool
    Draw (Window &window,
          const int first_visible_row,
          const uint32_t selected_row_idx,
          int &row_idx,
          int &num_rows_left)
    {
        if (num_rows_left <= 0)
            return false;

        if (m_row_idx >= first_visible_row)
        {
            window.MoveCursor(2, row_idx + 1);

            if (m_parent)
                m_parent->DrawTreeForChild (window, this, 0);
        
            if (m_might_have_children)
            {
                // It we can get UTF8 characters to work we should try to use the "symbol"
                // UTF8 string below
                //            const char *symbol = "";
                //            if (row.expanded)
                //                symbol = "\xe2\x96\xbd ";
                //            else
                //                symbol = "\xe2\x96\xb7 ";
                //            window.PutCString (symbol);
                
                // The ACS_DARROW and ACS_RARROW don't look very nice they are just a
                // 'v' or '>' character...
                //            if (expanded)
                //                window.PutChar (ACS_DARROW);
                //            else
                //                window.PutChar (ACS_RARROW);
                // Since we can't find any good looking right arrow/down arrow
                // symbols, just use a diamond...
                window.PutChar (ACS_DIAMOND);
                window.PutChar (ACS_HLINE);
            }
            bool highlight =
              (selected_row_idx == static_cast<size_t>(m_row_idx)) && window.IsActive();

            if (highlight)
                window.AttributeOn(A_REVERSE);

            m_delegate.TreeDelegateDrawTreeItem(*this, window);

            if (highlight)
                window.AttributeOff(A_REVERSE);
            ++row_idx;
            --num_rows_left;
        }

        if (num_rows_left <= 0)
            return false; // We are done drawing...

        if (IsExpanded())
        {
            for (auto &item : m_children)
            {
                // If we displayed all the rows and item.Draw() returns
                // false we are done drawing and can exit this for loop
                if (item.Draw(window, first_visible_row, selected_row_idx, row_idx, num_rows_left) == false)
                    break;
            }
        }
        return num_rows_left >= 0; // Return true if not done drawing yet
    }
    
    void
    DrawTreeForChild (Window &window, TreeItem *child, uint32_t reverse_depth)
    {
        if (m_parent)
            m_parent->DrawTreeForChild (window, this, reverse_depth + 1);
        
        if (&m_children.back() == child)
        {
            // Last child
            if (reverse_depth == 0)
            {
                window.PutChar (ACS_LLCORNER);
                window.PutChar (ACS_HLINE);
            }
            else
            {
                window.PutChar (' ');
                window.PutChar (' ');
            }
        }
        else
        {
            if (reverse_depth == 0)
            {
                window.PutChar (ACS_LTEE);
                window.PutChar (ACS_HLINE);
            }
            else
            {
                window.PutChar (ACS_VLINE);
                window.PutChar (' ');
            }
        }
    }
    
    TreeItem *
    GetItemForRowIndex (uint32_t row_idx)
    {
        if (static_cast<uint32_t>(m_row_idx) == row_idx)
            return this;
        if (m_children.empty())
            return NULL;
        if (IsExpanded())
        {
            for (auto &item : m_children)
            {
                TreeItem *selected_item_ptr = item.GetItemForRowIndex(row_idx);
                if (selected_item_ptr)
                    return selected_item_ptr;
            }
        }
        return NULL;
    }
    
    void *
    GetUserData() const
    {
        return m_user_data;
    }
    
    void
    SetUserData (void *user_data)
    {
        m_user_data = user_data;
    }

    uint64_t
    GetIdentifier() const
    {
        return m_identifier;
    }
    
    void
    SetIdentifier (uint64_t identifier)
    {
        m_identifier = identifier;
    }

    void
    SetMightHaveChildren (bool b)
    {
        m_might_have_children = b;
    }

protected:
    TreeItem *m_parent;
    TreeDelegate &m_delegate;
    void *m_user_data;
    uint64_t m_identifier;
    int m_row_idx; // Zero based visible row index, -1 if not visible or for the root item
    std::vector<TreeItem> m_children;
    bool m_might_have_children;
    bool m_is_expanded;
};

class TreeWindowDelegate : public WindowDelegate
{
public:
    TreeWindowDelegate (Debugger &debugger, const TreeDelegateSP &delegate_sp) :
        m_debugger (debugger),
        m_delegate_sp (delegate_sp),
        m_root (NULL, *delegate_sp, true),
        m_selected_item (NULL),
        m_num_rows (0),
        m_selected_row_idx (0),
        m_first_visible_row (0),
        m_min_x (0),
        m_min_y (0),
        m_max_x (0),
        m_max_y (0)
    {
    }
    
    int
    NumVisibleRows () const
    {
        return m_max_y - m_min_y;
    }

    bool
    WindowDelegateDraw (Window &window, bool force) override
    {
        ExecutionContext exe_ctx (m_debugger.GetCommandInterpreter().GetExecutionContext());
        Process *process = exe_ctx.GetProcessPtr();
        
        bool display_content = false;
        if (process)
        {
            StateType state = process->GetState();
            if (StateIsStoppedState(state, true))
            {
                // We are stopped, so it is ok to
                display_content = true;
            }
            else if (StateIsRunningState(state))
            {
                return true; // Don't do any updating when we are running
            }
        }

        m_min_x = 2;
        m_min_y = 1;
        m_max_x = window.GetWidth() - 1;
        m_max_y = window.GetHeight() - 1;
        
        window.Erase();
        window.DrawTitleBox (window.GetName());

        if (display_content)
        {
            const int num_visible_rows = NumVisibleRows();
            m_num_rows = 0;
            m_root.CalculateRowIndexes(m_num_rows);
            
            // If we unexpanded while having something selected our
            // total number of rows is less than the num visible rows,
            // then make sure we show all the rows by setting the first
            // visible row accordingly.
            if (m_first_visible_row > 0 && m_num_rows < num_visible_rows)
                m_first_visible_row = 0;
            
            // Make sure the selected row is always visible
            if (m_selected_row_idx < m_first_visible_row)
                m_first_visible_row = m_selected_row_idx;
            else if (m_first_visible_row + num_visible_rows <= m_selected_row_idx)
                m_first_visible_row = m_selected_row_idx - num_visible_rows + 1;
            
            int row_idx = 0;
            int num_rows_left = num_visible_rows;
            m_root.Draw (window, m_first_visible_row, m_selected_row_idx, row_idx, num_rows_left);
            // Get the selected row
            m_selected_item = m_root.GetItemForRowIndex (m_selected_row_idx);
        }
        else
        {
            m_selected_item = NULL;
        }
        
        window.DeferredRefresh();
        
        
        return true; // Drawing handled
    }

    const char *
    WindowDelegateGetHelpText () override
    {
        return "Thread window keyboard shortcuts:";
    }
    
    KeyHelp *
    WindowDelegateGetKeyHelp () override
    {
        static curses::KeyHelp g_source_view_key_help[] = {
            { KEY_UP, "Select previous item" },
            { KEY_DOWN, "Select next item" },
            { KEY_RIGHT, "Expand the selected item" },
            { KEY_LEFT, "Unexpand the selected item or select parent if not expanded" },
            { KEY_PPAGE, "Page up" },
            { KEY_NPAGE, "Page down" },
            { 'h', "Show help dialog" },
            { ' ', "Toggle item expansion" },
            { ',', "Page up" },
            { '.', "Page down" },
            { '\0', NULL }
        };
        return g_source_view_key_help;
    }
    
    HandleCharResult
    WindowDelegateHandleChar (Window &window, int c) override
    {
        switch(c)
        {
            case ',':
            case KEY_PPAGE:
                // Page up key
                if (m_first_visible_row > 0)
                {
                    if (m_first_visible_row > m_max_y)
                        m_first_visible_row -= m_max_y;
                    else
                        m_first_visible_row = 0;
                    m_selected_row_idx = m_first_visible_row;
                    m_selected_item = m_root.GetItemForRowIndex(m_selected_row_idx);
                    if (m_selected_item)
                        m_selected_item->ItemWasSelected ();
                }
                return eKeyHandled;
                
            case '.':
            case KEY_NPAGE:
                // Page down key
                if (m_num_rows > m_max_y)
                {
                    if (m_first_visible_row + m_max_y < m_num_rows)
                    {
                        m_first_visible_row += m_max_y;
                        m_selected_row_idx = m_first_visible_row;
                        m_selected_item = m_root.GetItemForRowIndex(m_selected_row_idx);
                        if (m_selected_item)
                            m_selected_item->ItemWasSelected ();
                    }
                }
                return eKeyHandled;
                
            case KEY_UP:
                if (m_selected_row_idx > 0)
                {
                    --m_selected_row_idx;
                    m_selected_item = m_root.GetItemForRowIndex(m_selected_row_idx);
                    if (m_selected_item)
                        m_selected_item->ItemWasSelected ();
                }
                return eKeyHandled;

            case KEY_DOWN:
                if (m_selected_row_idx + 1 < m_num_rows)
                {
                    ++m_selected_row_idx;
                    m_selected_item = m_root.GetItemForRowIndex(m_selected_row_idx);
                    if (m_selected_item)
                        m_selected_item->ItemWasSelected ();
                }
                return eKeyHandled;
                
            case KEY_RIGHT:
                if (m_selected_item)
                {
                    if (!m_selected_item->IsExpanded())
                        m_selected_item->Expand();
                }
                return eKeyHandled;
                
            case KEY_LEFT:
                if (m_selected_item)
                {
                    if (m_selected_item->IsExpanded())
                        m_selected_item->Unexpand();
                    else if (m_selected_item->GetParent())
                    {
                        m_selected_row_idx = m_selected_item->GetParent()->GetRowIndex();
                        m_selected_item = m_root.GetItemForRowIndex(m_selected_row_idx);
                        if (m_selected_item)
                            m_selected_item->ItemWasSelected ();
                    }
                }
                return eKeyHandled;
                
            case ' ':
                // Toggle expansion state when SPACE is pressed
                if (m_selected_item)
                {
                    if (m_selected_item->IsExpanded())
                        m_selected_item->Unexpand();
                    else
                        m_selected_item->Expand();
                }
                return eKeyHandled;
                
            case 'h':
                window.CreateHelpSubwindow ();
                return eKeyHandled;
                
            default:
                break;
        }
        return eKeyNotHandled;
    }

protected:
    Debugger &m_debugger;
    TreeDelegateSP m_delegate_sp;
    TreeItem m_root;
    TreeItem *m_selected_item;
    int m_num_rows;
    int m_selected_row_idx;
    int m_first_visible_row;
    int m_min_x;
    int m_min_y;
    int m_max_x;
    int m_max_y;
};

class FrameTreeDelegate : public TreeDelegate
{
public:
    FrameTreeDelegate () :
        TreeDelegate()
    {
        FormatEntity::Parse ("frame #${frame.index}: {${function.name}${function.pc-offset}}}",
                             m_format);
    }

    ~FrameTreeDelegate() override = default;

    void
    TreeDelegateDrawTreeItem (TreeItem &item, Window &window) override
    {
        Thread* thread = (Thread*)item.GetUserData();
        if (thread)
        {
            const uint64_t frame_idx = item.GetIdentifier();
            StackFrameSP frame_sp = thread->GetStackFrameAtIndex(frame_idx);
            if (frame_sp)
            {
                StreamString strm;
                const SymbolContext &sc = frame_sp->GetSymbolContext(eSymbolContextEverything);
                ExecutionContext exe_ctx (frame_sp);
                if (FormatEntity::Format(m_format, strm, &sc, &exe_ctx, NULL, NULL, false, false))
                {
                    int right_pad = 1;
                    window.PutCStringTruncated(strm.GetString().c_str(), right_pad);
                }
            }
        }
    }

    void
    TreeDelegateGenerateChildren (TreeItem &item)  override
    {
        // No children for frames yet...
    }
    
    bool
    TreeDelegateItemSelected (TreeItem &item) override
    {
        Thread* thread = (Thread*)item.GetUserData();
        if (thread)
        {
            thread->GetProcess()->GetThreadList().SetSelectedThreadByID(thread->GetID());
            const uint64_t frame_idx = item.GetIdentifier();
            thread->SetSelectedFrameByIndex(frame_idx);
            return true;
        }
        return false;
    }

protected:
    FormatEntity::Entry m_format;
};

class ThreadTreeDelegate : public TreeDelegate
{
public:
    ThreadTreeDelegate (Debugger &debugger) :
        TreeDelegate(),
        m_debugger (debugger),
        m_tid (LLDB_INVALID_THREAD_ID),
        m_stop_id (UINT32_MAX)
    {
        FormatEntity::Parse ("thread #${thread.index}: tid = ${thread.id}{, stop reason = ${thread.stop-reason}}",
                             m_format);
    }

    ~ThreadTreeDelegate() override = default;

    ProcessSP
    GetProcess ()
    {
        return m_debugger.GetCommandInterpreter().GetExecutionContext().GetProcessSP();
    }

    ThreadSP
    GetThread (const TreeItem &item)
    {
        ProcessSP process_sp = GetProcess ();
        if (process_sp)
            return process_sp->GetThreadList().FindThreadByID(item.GetIdentifier());
        return ThreadSP();
    }
    
    void
    TreeDelegateDrawTreeItem (TreeItem &item, Window &window) override
    {
        ThreadSP thread_sp = GetThread (item);
        if (thread_sp)
        {
            StreamString strm;
            ExecutionContext exe_ctx (thread_sp);
            if (FormatEntity::Format (m_format, strm, NULL, &exe_ctx, NULL, NULL, false, false))
            {
                int right_pad = 1;
                window.PutCStringTruncated(strm.GetString().c_str(), right_pad);
            }
        }
    }

    void
    TreeDelegateGenerateChildren (TreeItem &item) override
    {
        ProcessSP process_sp = GetProcess ();
        if (process_sp && process_sp->IsAlive())
        {
            StateType state = process_sp->GetState();
            if (StateIsStoppedState(state, true))
            {
                ThreadSP thread_sp = GetThread (item);
                if (thread_sp)
                {
                    if (m_stop_id == process_sp->GetStopID() && thread_sp->GetID() == m_tid)
                        return; // Children are already up to date
                    if (!m_frame_delegate_sp)
                    {
                        // Always expand the thread item the first time we show it
                        m_frame_delegate_sp.reset (new FrameTreeDelegate());
                    }

                    m_stop_id = process_sp->GetStopID();
                    m_tid = thread_sp->GetID();
                    
                    TreeItem t (&item, *m_frame_delegate_sp, false);
                    size_t num_frames = thread_sp->GetStackFrameCount();
                    item.Resize (num_frames, t);
                    for (size_t i=0; i<num_frames; ++i)
                    {
                        item[i].SetUserData(thread_sp.get());
                        item[i].SetIdentifier(i);
                    }
                }
                return;
            }
        }
        item.ClearChildren();
    }
    
    bool
    TreeDelegateItemSelected (TreeItem &item) override
    {
        ProcessSP process_sp = GetProcess ();
        if (process_sp && process_sp->IsAlive())
        {
            StateType state = process_sp->GetState();
            if (StateIsStoppedState(state, true))
            {
                ThreadSP thread_sp = GetThread (item);
                if (thread_sp)
                {
                    ThreadList &thread_list = thread_sp->GetProcess()->GetThreadList();
                    Mutex::Locker locker (thread_list.GetMutex());
                    ThreadSP selected_thread_sp = thread_list.GetSelectedThread();
                    if (selected_thread_sp->GetID() != thread_sp->GetID())
                    {
                        thread_list.SetSelectedThreadByID(thread_sp->GetID());
                        return true;
                    }
                }
            }
        }
        return false;
    }

protected:
    Debugger &m_debugger;
    std::shared_ptr<FrameTreeDelegate> m_frame_delegate_sp;
    lldb::user_id_t m_tid;
    uint32_t m_stop_id;
    FormatEntity::Entry m_format;
};

class ThreadsTreeDelegate : public TreeDelegate
{
public:
    ThreadsTreeDelegate (Debugger &debugger) :
        TreeDelegate(),
        m_thread_delegate_sp (),
        m_debugger (debugger),
        m_stop_id (UINT32_MAX)
    {
        FormatEntity::Parse("process ${process.id}{, name = ${process.name}}",
                            m_format);
    }

    ~ThreadsTreeDelegate() override = default;

    ProcessSP
    GetProcess ()
    {
        return m_debugger.GetCommandInterpreter().GetExecutionContext().GetProcessSP();
    }

    void
    TreeDelegateDrawTreeItem (TreeItem &item, Window &window) override
    {
        ProcessSP process_sp = GetProcess ();
        if (process_sp && process_sp->IsAlive())
        {
            StreamString strm;
            ExecutionContext exe_ctx (process_sp);
            if (FormatEntity::Format (m_format, strm, NULL, &exe_ctx, NULL, NULL, false, false))
            {
                int right_pad = 1;
                window.PutCStringTruncated(strm.GetString().c_str(), right_pad);
            }
        }
    }

    void
    TreeDelegateGenerateChildren (TreeItem &item) override
    {
        ProcessSP process_sp = GetProcess ();
        if (process_sp && process_sp->IsAlive())
        {
            StateType state = process_sp->GetState();
            if (StateIsStoppedState(state, true))
            {
                const uint32_t stop_id = process_sp->GetStopID();
                if (m_stop_id == stop_id)
                    return; // Children are already up to date
                
                m_stop_id = stop_id;

                if (!m_thread_delegate_sp)
                {
                    // Always expand the thread item the first time we show it
                    //item.Expand();
                    m_thread_delegate_sp.reset (new ThreadTreeDelegate(m_debugger));
                }
                
                TreeItem t (&item, *m_thread_delegate_sp, false);
                ThreadList &threads = process_sp->GetThreadList();
                Mutex::Locker locker (threads.GetMutex());
                size_t num_threads = threads.GetSize();
                item.Resize (num_threads, t);
                for (size_t i=0; i<num_threads; ++i)
                {
                    item[i].SetIdentifier(threads.GetThreadAtIndex(i)->GetID());
                    item[i].SetMightHaveChildren(true);
                }
                return;
            }
        }
        item.ClearChildren();
    }
    
    bool
    TreeDelegateItemSelected (TreeItem &item) override
    {
        return false;
    }
    
protected:
    std::shared_ptr<ThreadTreeDelegate> m_thread_delegate_sp;
    Debugger &m_debugger;
    uint32_t m_stop_id;
    FormatEntity::Entry m_format;
};

class ValueObjectListDelegate : public WindowDelegate
{
public:
    ValueObjectListDelegate () :
        m_valobj_list (),
        m_rows (),
        m_selected_row (NULL),
        m_selected_row_idx (0),
        m_first_visible_row (0),
        m_num_rows (0),
        m_max_x (0),
        m_max_y (0)
    {
    }
    
    ValueObjectListDelegate (ValueObjectList &valobj_list) :
        m_valobj_list (valobj_list),
        m_rows (),
        m_selected_row (NULL),
        m_selected_row_idx (0),
        m_first_visible_row (0),
        m_num_rows (0),
        m_max_x (0),
        m_max_y (0)
    {
        SetValues (valobj_list);
    }

    ~ValueObjectListDelegate() override = default;

    void
    SetValues (ValueObjectList &valobj_list)
    {
        m_selected_row = NULL;
        m_selected_row_idx = 0;
        m_first_visible_row = 0;
        m_num_rows = 0;
        m_rows.clear();
        m_valobj_list = valobj_list;
        const size_t num_values = m_valobj_list.GetSize();
        for (size_t i=0; i<num_values; ++i)
            m_rows.push_back(Row(m_valobj_list.GetValueObjectAtIndex(i), NULL));
    }
    
    bool
    WindowDelegateDraw (Window &window, bool force) override
    {
        m_num_rows = 0;
        m_min_x = 2;
        m_min_y = 1;
        m_max_x = window.GetWidth() - 1;
        m_max_y = window.GetHeight() - 1;
        
        window.Erase();
        window.DrawTitleBox (window.GetName());
        
        const int num_visible_rows = NumVisibleRows();
        const int num_rows = CalculateTotalNumberRows (m_rows);
        
        // If we unexpanded while having something selected our
        // total number of rows is less than the num visible rows,
        // then make sure we show all the rows by setting the first
        // visible row accordingly.
        if (m_first_visible_row > 0 && num_rows < num_visible_rows)
            m_first_visible_row = 0;
        
        // Make sure the selected row is always visible
        if (m_selected_row_idx < m_first_visible_row)
            m_first_visible_row = m_selected_row_idx;
        else if (m_first_visible_row + num_visible_rows <= m_selected_row_idx)
            m_first_visible_row = m_selected_row_idx - num_visible_rows + 1;
        
        DisplayRows (window, m_rows, g_options);
        
        window.DeferredRefresh();
        
        // Get the selected row
        m_selected_row = GetRowForRowIndex (m_selected_row_idx);
        // Keep the cursor on the selected row so the highlight and the cursor
        // are always on the same line
        if (m_selected_row)
            window.MoveCursor (m_selected_row->x,
                               m_selected_row->y);
        
        return true; // Drawing handled
    }
    
    KeyHelp *
    WindowDelegateGetKeyHelp () override
    {
        static curses::KeyHelp g_source_view_key_help[] = {
            { KEY_UP, "Select previous item" },
            { KEY_DOWN, "Select next item" },
            { KEY_RIGHT, "Expand selected item" },
            { KEY_LEFT, "Unexpand selected item or select parent if not expanded" },
            { KEY_PPAGE, "Page up" },
            { KEY_NPAGE, "Page down" },
            { 'A', "Format as annotated address" },
            { 'b', "Format as binary" },
            { 'B', "Format as hex bytes with ASCII" },
            { 'c', "Format as character" },
            { 'd', "Format as a signed integer" },
            { 'D', "Format selected value using the default format for the type" },
            { 'f', "Format as float" },
            { 'h', "Show help dialog" },
            { 'i', "Format as instructions" },
            { 'o', "Format as octal" },
            { 'p', "Format as pointer" },
            { 's', "Format as C string" },
            { 't', "Toggle showing/hiding type names" },
            { 'u', "Format as an unsigned integer" },
            { 'x', "Format as hex" },
            { 'X', "Format as uppercase hex" },
            { ' ', "Toggle item expansion" },
            { ',', "Page up" },
            { '.', "Page down" },
            { '\0', NULL }
        };
        return g_source_view_key_help;
    }

    HandleCharResult
    WindowDelegateHandleChar (Window &window, int c) override
    {
        switch(c)
        {
            case 'x':
            case 'X':
            case 'o':
            case 's':
            case 'u':
            case 'd':
            case 'D':
            case 'i':
            case 'A':
            case 'p':
            case 'c':
            case 'b':
            case 'B':
            case 'f':
                // Change the format for the currently selected item
                if (m_selected_row)
                    m_selected_row->valobj->SetFormat (FormatForChar (c));
                return eKeyHandled;
                
            case 't':
                // Toggle showing type names
                g_options.show_types = !g_options.show_types;
                return eKeyHandled;
                
            case ',':
            case KEY_PPAGE:
                // Page up key
                if (m_first_visible_row > 0)
                {
                    if (static_cast<int>(m_first_visible_row) > m_max_y)
                        m_first_visible_row -= m_max_y;
                    else
                        m_first_visible_row = 0;
                    m_selected_row_idx = m_first_visible_row;
                }
                return eKeyHandled;
                
            case '.':
            case KEY_NPAGE:
                // Page down key
                if (m_num_rows > static_cast<size_t>(m_max_y))
                {
                    if (m_first_visible_row + m_max_y < m_num_rows)
                    {
                        m_first_visible_row += m_max_y;
                        m_selected_row_idx = m_first_visible_row;
                    }
                }
                return eKeyHandled;
                
            case KEY_UP:
                if (m_selected_row_idx > 0)
                    --m_selected_row_idx;
                return eKeyHandled;

            case KEY_DOWN:
                if (m_selected_row_idx + 1 < m_num_rows)
                    ++m_selected_row_idx;
                return eKeyHandled;
                
            case KEY_RIGHT:
                if (m_selected_row)
                {
                    if (!m_selected_row->expanded)
                        m_selected_row->Expand();
                }
                return eKeyHandled;
                
            case KEY_LEFT:
                if (m_selected_row)
                {
                    if (m_selected_row->expanded)
                        m_selected_row->Unexpand();
                    else if (m_selected_row->parent)
                        m_selected_row_idx = m_selected_row->parent->row_idx;
                }
                return eKeyHandled;
                
            case ' ':
                // Toggle expansion state when SPACE is pressed
                if (m_selected_row)
                {
                    if (m_selected_row->expanded)
                        m_selected_row->Unexpand();
                    else
                        m_selected_row->Expand();
                }
                return eKeyHandled;
                
            case 'h':
                window.CreateHelpSubwindow ();
                return eKeyHandled;

            default:
                break;
        }
        return eKeyNotHandled;
    }
    
protected:
    ValueObjectList m_valobj_list;
    std::vector<Row> m_rows;
    Row *m_selected_row;
    uint32_t m_selected_row_idx;
    uint32_t m_first_visible_row;
    uint32_t m_num_rows;
    int m_min_x;
    int m_min_y;
    int m_max_x;
    int m_max_y;

    static Format
    FormatForChar (int c)
    {
        switch (c)
        {
            case 'x': return eFormatHex;
            case 'X': return eFormatHexUppercase;
            case 'o': return eFormatOctal;
            case 's': return eFormatCString;
            case 'u': return eFormatUnsigned;
            case 'd': return eFormatDecimal;
            case 'D': return eFormatDefault;
            case 'i': return eFormatInstruction;
            case 'A': return eFormatAddressInfo;
            case 'p': return eFormatPointer;
            case 'c': return eFormatChar;
            case 'b': return eFormatBinary;
            case 'B': return eFormatBytesWithASCII;
            case 'f': return eFormatFloat;
        }
        return eFormatDefault;
    }
    
    bool
    DisplayRowObject (Window &window,
                      Row &row,
                      DisplayOptions &options,
                      bool highlight,
                      bool last_child)
    {
        ValueObject *valobj = row.valobj.get();
        
        if (valobj == NULL)
            return false;
    
        const char *type_name = options.show_types ? valobj->GetTypeName().GetCString() : NULL;
        const char *name = valobj->GetName().GetCString();
        const char *value = valobj->GetValueAsCString ();
        const char *summary = valobj->GetSummaryAsCString ();
        
        window.MoveCursor (row.x, row.y);
        
        row.DrawTree (window);
        
        if (highlight)
            window.AttributeOn(A_REVERSE);
        
        if (type_name && type_name[0])
            window.Printf ("(%s) ", type_name);
        
        if (name && name[0])
            window.PutCString(name);
        
        attr_t changd_attr = 0;
        if (valobj->GetValueDidChange())
            changd_attr = COLOR_PAIR(5) | A_BOLD;
        
        if (value && value[0])
        {
            window.PutCString(" = ");
            if (changd_attr)
                window.AttributeOn(changd_attr);
            window.PutCString (value);
            if (changd_attr)
                window.AttributeOff(changd_attr);
        }
        
        if (summary && summary[0])
        {
            window.PutChar(' ');
            if (changd_attr)
                window.AttributeOn(changd_attr);
            window.PutCString(summary);
            if (changd_attr)
                window.AttributeOff(changd_attr);
        }
        
        if (highlight)
            window.AttributeOff (A_REVERSE);
        
        return true;
    }

    void
    DisplayRows (Window &window,
                 std::vector<Row> &rows,
                 DisplayOptions &options)
    {
        // >   0x25B7
        // \/  0x25BD
        
        bool window_is_active = window.IsActive();
        for (auto &row : rows)
        {
            const bool last_child = row.parent && &rows[rows.size()-1] == &row;
            // Save the row index in each Row structure
            row.row_idx = m_num_rows;
            if ((m_num_rows >= m_first_visible_row) &&
                ((m_num_rows - m_first_visible_row) < static_cast<size_t>(NumVisibleRows())))
            {
                row.x = m_min_x;
                row.y = m_num_rows - m_first_visible_row + 1;
                if (DisplayRowObject (window,
                                      row,
                                      options,
                                      window_is_active && m_num_rows == m_selected_row_idx,
                                      last_child))
                {
                    ++m_num_rows;
                }
                else
                {
                    row.x = 0;
                    row.y = 0;
                }
            }
            else
            {
                row.x = 0;
                row.y = 0;
                ++m_num_rows;
            }
            
            if (row.expanded && !row.children.empty())
            {
                DisplayRows (window,
                             row.children,
                             options);
            }
        }
    }
    
    int
    CalculateTotalNumberRows (const std::vector<Row> &rows)
    {
        int row_count = 0;
        for (const auto &row : rows)
        {
            ++row_count;
            if (row.expanded)
                row_count += CalculateTotalNumberRows(row.children);
        }
        return row_count;
    }

    static Row *
    GetRowForRowIndexImpl (std::vector<Row> &rows, size_t &row_index)
    {
        for (auto &row : rows)
        {
            if (row_index == 0)
                return &row;
            else
            {
                --row_index;
                if (row.expanded && !row.children.empty())
                {
                    Row *result = GetRowForRowIndexImpl (row.children, row_index);
                    if (result)
                        return result;
                }
            }
        }
        return NULL;
    }
    
    Row *
    GetRowForRowIndex (size_t row_index)
    {
        return GetRowForRowIndexImpl (m_rows, row_index);
    }
    
    int
    NumVisibleRows () const
    {
        return m_max_y - m_min_y;
    }

    static DisplayOptions g_options;
};

class FrameVariablesWindowDelegate : public ValueObjectListDelegate
{
public:
    FrameVariablesWindowDelegate (Debugger &debugger) :
        ValueObjectListDelegate (),
        m_debugger (debugger),
        m_frame_block (NULL)
    {
    }

    ~FrameVariablesWindowDelegate() override = default;

    const char *
    WindowDelegateGetHelpText () override
    {
        return "Frame variable window keyboard shortcuts:";
    }
    
    bool
    WindowDelegateDraw (Window &window, bool force) override
    {
        ExecutionContext exe_ctx (m_debugger.GetCommandInterpreter().GetExecutionContext());
        Process *process = exe_ctx.GetProcessPtr();
        Block *frame_block = NULL;
        StackFrame *frame = NULL;
        
        if (process)
        {
            StateType state = process->GetState();
            if (StateIsStoppedState(state, true))
            {
                frame = exe_ctx.GetFramePtr();
                if (frame)
                    frame_block = frame->GetFrameBlock ();
            }
            else if (StateIsRunningState(state))
            {
                return true; // Don't do any updating when we are running
            }
        }

        ValueObjectList local_values;
        if (frame_block)
        {
            // Only update the variables if they have changed
            if (m_frame_block != frame_block)
            {
                m_frame_block = frame_block;

                VariableList *locals = frame->GetVariableList(true);
                if (locals)
                {
                    const DynamicValueType use_dynamic = eDynamicDontRunTarget;
                    const size_t num_locals = locals->GetSize();
                    for (size_t i=0; i<num_locals; ++i)
                    {
                        ValueObjectSP value_sp = frame->GetValueObjectForFrameVariable (locals->GetVariableAtIndex(i), use_dynamic);
                        if (value_sp)
                        {
                            ValueObjectSP synthetic_value_sp = value_sp->GetSyntheticValue();
                            if (synthetic_value_sp)
                                local_values.Append(synthetic_value_sp);
                            else
                                local_values.Append(value_sp);

                        }
                    }
                    // Update the values
                    SetValues(local_values);
                }
            }
        }
        else
        {
            m_frame_block = NULL;
            // Update the values with an empty list if there is no frame
            SetValues(local_values);
        }
        
        return ValueObjectListDelegate::WindowDelegateDraw (window, force);
    }

protected:
    Debugger &m_debugger;
    Block *m_frame_block;
};

class RegistersWindowDelegate : public ValueObjectListDelegate
{
public:
    RegistersWindowDelegate (Debugger &debugger) :
        ValueObjectListDelegate (),
        m_debugger (debugger)
    {
    }

    ~RegistersWindowDelegate() override = default;

    const char *
    WindowDelegateGetHelpText () override
    {
        return "Register window keyboard shortcuts:";
    }

    bool
    WindowDelegateDraw (Window &window, bool force) override
    {
        ExecutionContext exe_ctx (m_debugger.GetCommandInterpreter().GetExecutionContext());
        StackFrame *frame = exe_ctx.GetFramePtr();
        
        ValueObjectList value_list;
        if (frame)
        {
            if (frame->GetStackID() != m_stack_id)
            {
                m_stack_id = frame->GetStackID();
                RegisterContextSP reg_ctx (frame->GetRegisterContext());
                if (reg_ctx)
                {
                    const uint32_t num_sets = reg_ctx->GetRegisterSetCount();
                    for (uint32_t set_idx = 0; set_idx < num_sets; ++set_idx)
                    {
                        value_list.Append(ValueObjectRegisterSet::Create (frame, reg_ctx, set_idx));
                    }
                }
                SetValues(value_list);
            }
        }
        else
        {
            Process *process = exe_ctx.GetProcessPtr();
            if (process && process->IsAlive())
                return true; // Don't do any updating if we are running
            else
            {
                // Update the values with an empty list if there
                // is no process or the process isn't alive anymore
                SetValues(value_list);
            }
        }
        return ValueObjectListDelegate::WindowDelegateDraw (window, force);
    }
    
protected:
    Debugger &m_debugger;
    StackID m_stack_id;
};

static const char *
CursesKeyToCString (int ch)
{
    static char g_desc[32];
    if (ch >= KEY_F0 && ch < KEY_F0 + 64)
    {
        snprintf(g_desc, sizeof(g_desc), "F%u", ch - KEY_F0);
        return g_desc;
    }
    switch (ch)
    {
        case KEY_DOWN:  return "down";
        case KEY_UP:    return "up";
        case KEY_LEFT:  return "left";
        case KEY_RIGHT: return "right";
        case KEY_HOME:  return "home";
        case KEY_BACKSPACE: return "backspace";
        case KEY_DL:        return "delete-line";
        case KEY_IL:        return "insert-line";
        case KEY_DC:        return "delete-char";
        case KEY_IC:        return "insert-char";
        case KEY_CLEAR:     return "clear";
        case KEY_EOS:       return "clear-to-eos";
        case KEY_EOL:       return "clear-to-eol";
        case KEY_SF:        return "scroll-forward";
        case KEY_SR:        return "scroll-backward";
        case KEY_NPAGE:     return "page-down";
        case KEY_PPAGE:     return "page-up";
        case KEY_STAB:      return "set-tab";
        case KEY_CTAB:      return "clear-tab";
        case KEY_CATAB:     return "clear-all-tabs";
        case KEY_ENTER:     return "enter";
        case KEY_PRINT:     return "print";
        case KEY_LL:        return "lower-left key";
        case KEY_A1:        return "upper left of keypad";
        case KEY_A3:        return "upper right of keypad";
        case KEY_B2:        return "center of keypad";
        case KEY_C1:        return "lower left of keypad";
        case KEY_C3:        return "lower right of keypad";
        case KEY_BTAB:      return "back-tab key";
        case KEY_BEG:       return "begin key";
        case KEY_CANCEL:    return "cancel key";
        case KEY_CLOSE:     return "close key";
        case KEY_COMMAND:   return "command key";
        case KEY_COPY:      return "copy key";
        case KEY_CREATE:    return "create key";
        case KEY_END:       return "end key";
        case KEY_EXIT:      return "exit key";
        case KEY_FIND:      return "find key";
        case KEY_HELP:      return "help key";
        case KEY_MARK:      return "mark key";
        case KEY_MESSAGE:   return "message key";
        case KEY_MOVE:      return "move key";
        case KEY_NEXT:      return "next key";
        case KEY_OPEN:      return "open key";
        case KEY_OPTIONS:   return "options key";
        case KEY_PREVIOUS:  return "previous key";
        case KEY_REDO:      return "redo key";
        case KEY_REFERENCE: return "reference key";
        case KEY_REFRESH:   return "refresh key";
        case KEY_REPLACE:   return "replace key";
        case KEY_RESTART:   return "restart key";
        case KEY_RESUME:    return "resume key";
        case KEY_SAVE:      return "save key";
        case KEY_SBEG:      return "shifted begin key";
        case KEY_SCANCEL:   return "shifted cancel key";
        case KEY_SCOMMAND:  return "shifted command key";
        case KEY_SCOPY:     return "shifted copy key";
        case KEY_SCREATE:   return "shifted create key";
        case KEY_SDC:       return "shifted delete-character key";
        case KEY_SDL:       return "shifted delete-line key";
        case KEY_SELECT:    return "select key";
        case KEY_SEND:      return "shifted end key";
        case KEY_SEOL:      return "shifted clear-to-end-of-line key";
        case KEY_SEXIT:     return "shifted exit key";
        case KEY_SFIND:     return "shifted find key";
        case KEY_SHELP:     return "shifted help key";
        case KEY_SHOME:     return "shifted home key";
        case KEY_SIC:       return "shifted insert-character key";
        case KEY_SLEFT:     return "shifted left-arrow key";
        case KEY_SMESSAGE:  return "shifted message key";
        case KEY_SMOVE:     return "shifted move key";
        case KEY_SNEXT:     return "shifted next key";
        case KEY_SOPTIONS:  return "shifted options key";
        case KEY_SPREVIOUS: return "shifted previous key";
        case KEY_SPRINT:    return "shifted print key";
        case KEY_SREDO:     return "shifted redo key";
        case KEY_SREPLACE:  return "shifted replace key";
        case KEY_SRIGHT:    return "shifted right-arrow key";
        case KEY_SRSUME:    return "shifted resume key";
        case KEY_SSAVE:     return "shifted save key";
        case KEY_SSUSPEND:  return "shifted suspend key";
        case KEY_SUNDO:     return "shifted undo key";
        case KEY_SUSPEND:   return "suspend key";
        case KEY_UNDO:      return "undo key";
        case KEY_MOUSE:     return "Mouse event has occurred";
        case KEY_RESIZE:    return "Terminal resize event";
#ifdef KEY_EVENT
        case KEY_EVENT:     return "We were interrupted by an event";
#endif
        case KEY_RETURN:    return "return";
        case ' ':           return "space";
        case '\t':          return "tab";
        case KEY_ESCAPE:    return "escape";
        default:
            if (isprint(ch))
                snprintf(g_desc, sizeof(g_desc), "%c", ch);
            else
                snprintf(g_desc, sizeof(g_desc), "\\x%2.2x", ch);
            return g_desc;
    }
    return NULL;
}

HelpDialogDelegate::HelpDialogDelegate (const char *text, KeyHelp *key_help_array) :
    m_text (),
    m_first_visible_line (0)
{
    if (text && text[0])
    {
        m_text.SplitIntoLines(text);
        m_text.AppendString("");
    }
    if (key_help_array)
    {
        for (KeyHelp *key = key_help_array; key->ch; ++key)
        {
            StreamString key_description;
            key_description.Printf("%10s - %s", CursesKeyToCString(key->ch), key->description);
            m_text.AppendString(std::move(key_description.GetString()));
        }
    }
}

HelpDialogDelegate::~HelpDialogDelegate() = default;
    
bool
HelpDialogDelegate::WindowDelegateDraw (Window &window, bool force)
{
    window.Erase();
    const int window_height = window.GetHeight();
    int x = 2;
    int y = 1;
    const int min_y = y;
    const int max_y = window_height - 1 - y;
    const size_t num_visible_lines = max_y - min_y + 1;
    const size_t num_lines = m_text.GetSize();
    const char *bottom_message;
    if (num_lines <= num_visible_lines)
        bottom_message = "Press any key to exit";
    else
        bottom_message = "Use arrows to scroll, any other key to exit";
    window.DrawTitleBox(window.GetName(), bottom_message);
    while (y <= max_y)
    {
        window.MoveCursor(x, y);
        window.PutCStringTruncated(m_text.GetStringAtIndex(m_first_visible_line + y - min_y), 1);
        ++y;
    }
    return true;
}

HandleCharResult
HelpDialogDelegate::WindowDelegateHandleChar (Window &window, int key)
{
    bool done = false;
    const size_t num_lines = m_text.GetSize();
    const size_t num_visible_lines = window.GetHeight() - 2;
    
    if (num_lines <= num_visible_lines)
    {
        done = true;
        // If we have all lines visible and don't need scrolling, then any
        // key press will cause us to exit
    }
    else
    {
        switch (key)
        {
            case KEY_UP:
                if (m_first_visible_line > 0)
                    --m_first_visible_line;
                break;

            case KEY_DOWN:
                if (m_first_visible_line + num_visible_lines < num_lines)
                    ++m_first_visible_line;
                break;

            case KEY_PPAGE:
            case ',':
                if (m_first_visible_line > 0)
                {
                    if (static_cast<size_t>(m_first_visible_line) >= num_visible_lines)
                        m_first_visible_line -= num_visible_lines;
                    else
                        m_first_visible_line = 0;
                }
                break;

            case KEY_NPAGE:
            case '.':
                if (m_first_visible_line + num_visible_lines < num_lines)
                {
                    m_first_visible_line += num_visible_lines;
                    if (static_cast<size_t>(m_first_visible_line) > num_lines)
                        m_first_visible_line = num_lines - num_visible_lines;
                }
                break;

            default:
                done = true;
                break;
        }
    }
    if (done)
        window.GetParent()->RemoveSubWindow(&window);
    return eKeyHandled;
}

class ApplicationDelegate :
    public WindowDelegate,
    public MenuDelegate
{
public:
    enum {
        eMenuID_LLDB = 1,
        eMenuID_LLDBAbout,
        eMenuID_LLDBExit,
        
        eMenuID_Target,
        eMenuID_TargetCreate,
        eMenuID_TargetDelete,
        
        eMenuID_Process,
        eMenuID_ProcessAttach,
        eMenuID_ProcessDetach,
        eMenuID_ProcessLaunch,
        eMenuID_ProcessContinue,
        eMenuID_ProcessHalt,
        eMenuID_ProcessKill,
        
        eMenuID_Thread,
        eMenuID_ThreadStepIn,
        eMenuID_ThreadStepOver,
        eMenuID_ThreadStepOut,
        
        eMenuID_View,
        eMenuID_ViewBacktrace,
        eMenuID_ViewRegisters,
        eMenuID_ViewSource,
        eMenuID_ViewVariables,
        
        eMenuID_Help,
        eMenuID_HelpGUIHelp
    };

    ApplicationDelegate (Application &app, Debugger &debugger) :
        WindowDelegate (),
        MenuDelegate (),
        m_app (app),
        m_debugger (debugger)
    {
    }

    ~ApplicationDelegate() override = default;

    bool
    WindowDelegateDraw (Window &window, bool force) override
    {
        return false; // Drawing not handled, let standard window drawing happen
    }
    
    HandleCharResult
    WindowDelegateHandleChar (Window &window, int key) override
    {
        switch (key)
        {
            case '\t':
                window.SelectNextWindowAsActive();
                return eKeyHandled;

            case 'h':
                window.CreateHelpSubwindow();
                return eKeyHandled;

            case KEY_ESCAPE:
                return eQuitApplication;

            default:
                break;
        }
        return eKeyNotHandled;
    }

    const char *
    WindowDelegateGetHelpText () override
    {
        return "Welcome to the LLDB curses GUI.\n\n"
        "Press the TAB key to change the selected view.\n"
        "Each view has its own keyboard shortcuts, press 'h' to open a dialog to display them.\n\n"
        "Common key bindings for all views:";
    }
    
    KeyHelp *
    WindowDelegateGetKeyHelp () override
    {
        static curses::KeyHelp g_source_view_key_help[] = {
            { '\t', "Select next view" },
            { 'h', "Show help dialog with view specific key bindings" },
            { ',', "Page up" },
            { '.', "Page down" },
            { KEY_UP, "Select previous" },
            { KEY_DOWN, "Select next" },
            { KEY_LEFT, "Unexpand or select parent" },
            { KEY_RIGHT, "Expand" },
            { KEY_PPAGE, "Page up" },
            { KEY_NPAGE, "Page down" },
            { '\0', NULL }
        };
        return g_source_view_key_help;
    }
    
    MenuActionResult
    MenuDelegateAction (Menu &menu) override
    {
        switch (menu.GetIdentifier())
        {
            case eMenuID_ThreadStepIn:
                {
                    ExecutionContext exe_ctx = m_debugger.GetCommandInterpreter().GetExecutionContext();
                    if (exe_ctx.HasThreadScope())
                    {
                        Process *process = exe_ctx.GetProcessPtr();
                        if (process && process->IsAlive() && StateIsStoppedState (process->GetState(), true))
                            exe_ctx.GetThreadRef().StepIn(true);
                    }
                }
                return MenuActionResult::Handled;
                
            case eMenuID_ThreadStepOut:
                {
                    ExecutionContext exe_ctx = m_debugger.GetCommandInterpreter().GetExecutionContext();
                    if (exe_ctx.HasThreadScope())
                    {
                        Process *process = exe_ctx.GetProcessPtr();
                        if (process && process->IsAlive() && StateIsStoppedState (process->GetState(), true))
                            exe_ctx.GetThreadRef().StepOut();
                    }
                }
                return MenuActionResult::Handled;
                
            case eMenuID_ThreadStepOver:
                {
                    ExecutionContext exe_ctx = m_debugger.GetCommandInterpreter().GetExecutionContext();
                    if (exe_ctx.HasThreadScope())
                    {
                        Process *process = exe_ctx.GetProcessPtr();
                        if (process && process->IsAlive() && StateIsStoppedState (process->GetState(), true))
                            exe_ctx.GetThreadRef().StepOver(true);
                    }
                }
                return MenuActionResult::Handled;

            case eMenuID_ProcessContinue:
                {
                    ExecutionContext exe_ctx = m_debugger.GetCommandInterpreter().GetExecutionContext();
                    if (exe_ctx.HasProcessScope())
                    {
                        Process *process = exe_ctx.GetProcessPtr();
                        if (process && process->IsAlive() && StateIsStoppedState (process->GetState(), true))
                            process->Resume();
                    }
                }
                return MenuActionResult::Handled;

            case eMenuID_ProcessKill:
                {
                    ExecutionContext exe_ctx = m_debugger.GetCommandInterpreter().GetExecutionContext();
                    if (exe_ctx.HasProcessScope())
                    {
                        Process *process = exe_ctx.GetProcessPtr();
                        if (process && process->IsAlive())
                            process->Destroy(false);
                    }
                }
                return MenuActionResult::Handled;

            case eMenuID_ProcessHalt:
                {
                    ExecutionContext exe_ctx = m_debugger.GetCommandInterpreter().GetExecutionContext();
                    if (exe_ctx.HasProcessScope())
                    {
                        Process *process = exe_ctx.GetProcessPtr();
                        if (process && process->IsAlive())
                            process->Halt();
                    }
                }
                return MenuActionResult::Handled;

            case eMenuID_ProcessDetach:
                {
                    ExecutionContext exe_ctx = m_debugger.GetCommandInterpreter().GetExecutionContext();
                    if (exe_ctx.HasProcessScope())
                    {
                        Process *process = exe_ctx.GetProcessPtr();
                        if (process && process->IsAlive())
                            process->Detach(false);
                    }
                }
                return MenuActionResult::Handled;

            case eMenuID_Process:
                {
                    // Populate the menu with all of the threads if the process is stopped when
                    // the Process menu gets selected and is about to display its submenu.
                    Menus &submenus = menu.GetSubmenus();
                    ExecutionContext exe_ctx = m_debugger.GetCommandInterpreter().GetExecutionContext();
                    Process *process = exe_ctx.GetProcessPtr();
                    if (process && process->IsAlive() && StateIsStoppedState (process->GetState(), true))
                    {
                        if (submenus.size() == 7)
                            menu.AddSubmenu (MenuSP (new Menu(Menu::Type::Separator)));
                        else if (submenus.size() > 8)
                            submenus.erase (submenus.begin() + 8, submenus.end());
                        
                        ThreadList &threads = process->GetThreadList();
                        Mutex::Locker locker (threads.GetMutex());
                        size_t num_threads = threads.GetSize();
                        for (size_t i=0; i<num_threads; ++i)
                        {
                            ThreadSP thread_sp = threads.GetThreadAtIndex(i);
                            char menu_char = '\0';
                            if (i < 9)
                                menu_char = '1' + i;
                            StreamString thread_menu_title;
                            thread_menu_title.Printf("Thread %u", thread_sp->GetIndexID());
                            const char *thread_name = thread_sp->GetName();
                            if (thread_name && thread_name[0])
                                thread_menu_title.Printf (" %s", thread_name);
                            else
                            {
                                const char *queue_name = thread_sp->GetQueueName();
                                if (queue_name && queue_name[0])
                                    thread_menu_title.Printf (" %s", queue_name);
                            }
                            menu.AddSubmenu (MenuSP (new Menu(thread_menu_title.GetString().c_str(), NULL, menu_char, thread_sp->GetID())));
                        }
                    }
                    else if (submenus.size() > 7)
                    {
                        // Remove the separator and any other thread submenu items
                        // that were previously added
                        submenus.erase (submenus.begin() + 7, submenus.end());
                    }
                    // Since we are adding and removing items we need to recalculate the name lengths
                    menu.RecalculateNameLengths();
                }
                return MenuActionResult::Handled;
                
            case eMenuID_ViewVariables:
                {
                    WindowSP main_window_sp = m_app.GetMainWindow();
                    WindowSP source_window_sp = main_window_sp->FindSubWindow("Source");
                    WindowSP variables_window_sp = main_window_sp->FindSubWindow("Variables");
                    WindowSP registers_window_sp = main_window_sp->FindSubWindow("Registers");
                    const Rect source_bounds = source_window_sp->GetBounds();

                    if (variables_window_sp)
                    {
                        const Rect variables_bounds = variables_window_sp->GetBounds();

                        main_window_sp->RemoveSubWindow(variables_window_sp.get());

                        if (registers_window_sp)
                        {
                            // We have a registers window, so give all the area back to the registers window
                            Rect registers_bounds = variables_bounds;
                            registers_bounds.size.width = source_bounds.size.width;
                            registers_window_sp->SetBounds(registers_bounds);
                        }
                        else
                        {
                            // We have no registers window showing so give the bottom
                            // area back to the source view
                            source_window_sp->Resize (source_bounds.size.width,
                                                      source_bounds.size.height + variables_bounds.size.height);
                        }
                    }
                    else
                    {
                        Rect new_variables_rect;
                        if (registers_window_sp)
                        {
                            // We have a registers window so split the area of the registers
                            // window into two columns where the left hand side will be the
                            // variables and the right hand side will be the registers
                            const Rect variables_bounds = registers_window_sp->GetBounds();
                            Rect new_registers_rect;
                            variables_bounds.VerticalSplitPercentage (0.50, new_variables_rect, new_registers_rect);
                            registers_window_sp->SetBounds (new_registers_rect);
                        }
                        else
                        {
                            // No variables window, grab the bottom part of the source window
                            Rect new_source_rect;
                            source_bounds.HorizontalSplitPercentage (0.70, new_source_rect, new_variables_rect);
                            source_window_sp->SetBounds (new_source_rect);
                        }
                        WindowSP new_window_sp = main_window_sp->CreateSubWindow ("Variables",
                                                                                  new_variables_rect,
                                                                                  false);
                        new_window_sp->SetDelegate (WindowDelegateSP(new FrameVariablesWindowDelegate(m_debugger)));
                    }
                    touchwin(stdscr);
                }
                return MenuActionResult::Handled;

            case eMenuID_ViewRegisters:
                {
                    WindowSP main_window_sp = m_app.GetMainWindow();
                    WindowSP source_window_sp = main_window_sp->FindSubWindow("Source");
                    WindowSP variables_window_sp = main_window_sp->FindSubWindow("Variables");
                    WindowSP registers_window_sp = main_window_sp->FindSubWindow("Registers");
                    const Rect source_bounds = source_window_sp->GetBounds();

                    if (registers_window_sp)
                    {
                        if (variables_window_sp)
                        {
                            const Rect variables_bounds = variables_window_sp->GetBounds();

                            // We have a variables window, so give all the area back to the variables window
                            variables_window_sp->Resize (variables_bounds.size.width + registers_window_sp->GetWidth(),
                                                         variables_bounds.size.height);
                        }
                        else
                        {
                            // We have no variables window showing so give the bottom
                            // area back to the source view
                            source_window_sp->Resize (source_bounds.size.width,
                                                      source_bounds.size.height + registers_window_sp->GetHeight());
                        }
                        main_window_sp->RemoveSubWindow(registers_window_sp.get());
                    }
                    else
                    {
                        Rect new_regs_rect;
                        if (variables_window_sp)
                        {
                            // We have a variables window, split it into two columns
                            // where the left hand side will be the variables and the
                            // right hand side will be the registers
                            const Rect variables_bounds = variables_window_sp->GetBounds();
                            Rect new_vars_rect;
                            variables_bounds.VerticalSplitPercentage (0.50, new_vars_rect, new_regs_rect);
                            variables_window_sp->SetBounds (new_vars_rect);
                        }
                        else
                        {
                            // No registers window, grab the bottom part of the source window
                            Rect new_source_rect;
                            source_bounds.HorizontalSplitPercentage (0.70, new_source_rect, new_regs_rect);
                            source_window_sp->SetBounds (new_source_rect);
                        }
                        WindowSP new_window_sp = main_window_sp->CreateSubWindow ("Registers",
                                                                                  new_regs_rect,
                                                                                  false);
                        new_window_sp->SetDelegate (WindowDelegateSP(new RegistersWindowDelegate(m_debugger)));
                    }
                    touchwin(stdscr);
                }
                return MenuActionResult::Handled;
                
            case eMenuID_HelpGUIHelp:
                m_app.GetMainWindow ()->CreateHelpSubwindow();
                return MenuActionResult::Handled;
        
            default:
                break;
        }

        return MenuActionResult::NotHandled;
    }
protected:
    Application &m_app;
    Debugger &m_debugger;
};

class StatusBarWindowDelegate : public WindowDelegate
{
public:
    StatusBarWindowDelegate (Debugger &debugger) :
        m_debugger (debugger)
    {
        FormatEntity::Parse("Thread: ${thread.id%tid}",
                            m_format);
    }

    ~StatusBarWindowDelegate() override = default;

    bool
    WindowDelegateDraw (Window &window, bool force) override
    {
        ExecutionContext exe_ctx = m_debugger.GetCommandInterpreter().GetExecutionContext();
        Process *process = exe_ctx.GetProcessPtr();
        Thread *thread = exe_ctx.GetThreadPtr();
        StackFrame *frame = exe_ctx.GetFramePtr();
        window.Erase();
        window.SetBackground(2);
        window.MoveCursor (0, 0);
        if (process)
        {
            const StateType state = process->GetState();
            window.Printf ("Process: %5" PRIu64 " %10s", process->GetID(), StateAsCString(state));

            if (StateIsStoppedState(state, true))
            {
                StreamString strm;
                if (thread && FormatEntity::Format (m_format, strm, NULL, &exe_ctx, NULL, NULL, false, false))
                {
                    window.MoveCursor (40, 0);
                    window.PutCStringTruncated(strm.GetString().c_str(), 1);
                }

                window.MoveCursor (60, 0);
                if (frame)
                    window.Printf ("Frame: %3u  PC = 0x%16.16" PRIx64, frame->GetFrameIndex(), frame->GetFrameCodeAddress().GetOpcodeLoadAddress (exe_ctx.GetTargetPtr()));
            }
            else if (state == eStateExited)
            {
                const char *exit_desc = process->GetExitDescription();
                const int exit_status = process->GetExitStatus();
                if (exit_desc && exit_desc[0])
                    window.Printf (" with status = %i (%s)", exit_status, exit_desc);
                else
                    window.Printf (" with status = %i", exit_status);
            }
        }
        window.DeferredRefresh();
        return true;
    }

protected:
    Debugger &m_debugger;
    FormatEntity::Entry m_format;
};

class SourceFileWindowDelegate : public WindowDelegate
{
public:
    SourceFileWindowDelegate (Debugger &debugger) :
        WindowDelegate (),
        m_debugger (debugger),
        m_sc (),
        m_file_sp (),
        m_disassembly_scope (NULL),
        m_disassembly_sp (),
        m_disassembly_range (),
        m_title (),
        m_line_width (4),
        m_selected_line (0),
        m_pc_line (0),
        m_stop_id (0),
        m_frame_idx (UINT32_MAX),
        m_first_visible_line (0),
        m_min_x (0),
        m_min_y (0),
        m_max_x (0),
        m_max_y (0)
    {
    }

    ~SourceFileWindowDelegate() override = default;

    void
    Update (const SymbolContext &sc)
    {
        m_sc = sc;
    }

    uint32_t
    NumVisibleLines () const
    {
        return m_max_y - m_min_y;
    }

    const char *
    WindowDelegateGetHelpText () override
    {
        return "Source/Disassembly window keyboard shortcuts:";
    }

    KeyHelp *
    WindowDelegateGetKeyHelp () override
    {
        static curses::KeyHelp g_source_view_key_help[] = {
            { KEY_RETURN, "Run to selected line with one shot breakpoint" },
            { KEY_UP, "Select previous source line" },
            { KEY_DOWN, "Select next source line" },
            { KEY_PPAGE, "Page up" },
            { KEY_NPAGE, "Page down" },
            { 'b', "Set breakpoint on selected source/disassembly line" },
            { 'c', "Continue process" },
            { 'd', "Detach and resume process" },
            { 'D', "Detach with process suspended" },
            { 'h', "Show help dialog" },
            { 'k', "Kill process" },
            { 'n', "Step over (source line)" },
            { 'N', "Step over (single instruction)" },
            { 'o', "Step out" },
            { 's', "Step in (source line)" },
            { 'S', "Step in (single instruction)" },
            { ',', "Page up" },
            { '.', "Page down" },
            { '\0', NULL }
        };
        return g_source_view_key_help;
    }

    bool
    WindowDelegateDraw (Window &window, bool force) override
    {
        ExecutionContext exe_ctx = m_debugger.GetCommandInterpreter().GetExecutionContext();
        Process *process = exe_ctx.GetProcessPtr();
        Thread *thread = NULL;

        bool update_location = false;
        if (process)
        {
            StateType state = process->GetState();
            if (StateIsStoppedState(state, true))
            {
                // We are stopped, so it is ok to
                update_location = true;
            }
        }

        m_min_x = 1;
        m_min_y = 2;
        m_max_x = window.GetMaxX()-1;
        m_max_y = window.GetMaxY()-1;

        const uint32_t num_visible_lines = NumVisibleLines();
        StackFrameSP frame_sp;
        bool set_selected_line_to_pc = false;

        if (update_location)
        {
            const bool process_alive = process ? process->IsAlive() : false;
            bool thread_changed = false;
            if (process_alive)
            {
                thread = exe_ctx.GetThreadPtr();
                if (thread)
                {
                    frame_sp = thread->GetSelectedFrame();
                    auto tid = thread->GetID();
                    thread_changed = tid != m_tid;
                    m_tid = tid;
                }
                else
                {
                    if (m_tid != LLDB_INVALID_THREAD_ID)
                    {
                        thread_changed = true;
                        m_tid = LLDB_INVALID_THREAD_ID;
                    }
                }
            }
            const uint32_t stop_id = process ? process->GetStopID() : 0;
            const bool stop_id_changed = stop_id != m_stop_id;
            bool frame_changed = false;
            m_stop_id = stop_id;
            m_title.Clear();
            if (frame_sp)
            {
                m_sc = frame_sp->GetSymbolContext(eSymbolContextEverything);
                if (m_sc.module_sp)
                {
                    m_title.Printf("%s", m_sc.module_sp->GetFileSpec().GetFilename().GetCString());
                    ConstString func_name = m_sc.GetFunctionName();
                    if (func_name)
                        m_title.Printf("`%s", func_name.GetCString());
                }
                const uint32_t frame_idx = frame_sp->GetFrameIndex();
                frame_changed = frame_idx != m_frame_idx;
                m_frame_idx = frame_idx;
            }
            else
            {
                m_sc.Clear(true);
                frame_changed = m_frame_idx != UINT32_MAX;
                m_frame_idx = UINT32_MAX;
            }

            const bool context_changed = thread_changed || frame_changed || stop_id_changed;

            if (process_alive)
            {
                if (m_sc.line_entry.IsValid())
                {
                    m_pc_line = m_sc.line_entry.line;
                    if (m_pc_line != UINT32_MAX)
                        --m_pc_line; // Convert to zero based line number...
                    // Update the selected line if the stop ID changed...
                    if (context_changed)
                        m_selected_line = m_pc_line;

                    if (m_file_sp && m_file_sp->FileSpecMatches(m_sc.line_entry.file))
                    {
                        // Same file, nothing to do, we should either have the
                        // lines or not (source file missing)
                        if (m_selected_line >= static_cast<size_t>(m_first_visible_line))
                        {
                            if (m_selected_line >= m_first_visible_line + num_visible_lines)
                                m_first_visible_line = m_selected_line - 10;
                        }
                        else
                        {
                            if (m_selected_line > 10)
                                m_first_visible_line = m_selected_line - 10;
                            else
                                m_first_visible_line = 0;
                        }
                    }
                    else
                    {
                        // File changed, set selected line to the line with the PC
                        m_selected_line = m_pc_line;
                        m_file_sp = m_debugger.GetSourceManager().GetFile(m_sc.line_entry.file);
                        if (m_file_sp)
                        {
                            const size_t num_lines = m_file_sp->GetNumLines();
                            int m_line_width = 1;
                            for (size_t n = num_lines; n >= 10; n = n / 10)
                                ++m_line_width;

                            snprintf (m_line_format, sizeof(m_line_format), " %%%iu ", m_line_width);
                            if (num_lines < num_visible_lines || m_selected_line < num_visible_lines)
                                m_first_visible_line = 0;
                            else
                                m_first_visible_line = m_selected_line - 10;
                        }
                    }
                }
                else
                {
                    m_file_sp.reset();
                }

                if (!m_file_sp || m_file_sp->GetNumLines() == 0)
                {
                    // Show disassembly
                    bool prefer_file_cache = false;
                    if (m_sc.function)
                    {
                        if (m_disassembly_scope != m_sc.function)
                        {
                            m_disassembly_scope = m_sc.function;
                            m_disassembly_sp = m_sc.function->GetInstructions (exe_ctx, NULL, prefer_file_cache);
                            if (m_disassembly_sp)
                            {
                                set_selected_line_to_pc = true;
                                m_disassembly_range = m_sc.function->GetAddressRange();
                            }
                            else
                            {
                                m_disassembly_range.Clear();
                            }
                        }
                        else
                        {
                            set_selected_line_to_pc = context_changed;
                        }
                    }
                    else if (m_sc.symbol)
                    {
                        if (m_disassembly_scope != m_sc.symbol)
                        {
                            m_disassembly_scope = m_sc.symbol;
                            m_disassembly_sp = m_sc.symbol->GetInstructions (exe_ctx, NULL, prefer_file_cache);
                            if (m_disassembly_sp)
                            {
                                set_selected_line_to_pc = true;
                                m_disassembly_range.GetBaseAddress() = m_sc.symbol->GetAddress();
                                m_disassembly_range.SetByteSize(m_sc.symbol->GetByteSize());
                            }
                            else
                            {
                                m_disassembly_range.Clear();
                            }
                        }
                        else
                        {
                            set_selected_line_to_pc = context_changed;
                        }
                    }
                }
            }
            else
            {
                m_pc_line = UINT32_MAX;
            }
        }

        const int window_width = window.GetWidth();
        window.Erase();
        window.DrawTitleBox ("Sources");
        if (!m_title.GetString().empty())
        {
            window.AttributeOn(A_REVERSE);
            window.MoveCursor(1, 1);
            window.PutChar(' ');
            window.PutCStringTruncated(m_title.GetString().c_str(), 1);
            int x = window.GetCursorX();
            if (x < window_width - 1)
            {
                window.Printf ("%*s", window_width - x - 1, "");
            }
            window.AttributeOff(A_REVERSE);
        }

        Target *target = exe_ctx.GetTargetPtr();
        const size_t num_source_lines = GetNumSourceLines();
        if (num_source_lines > 0)
        {
            // Display source
            BreakpointLines bp_lines;
            if (target)
            {
                BreakpointList &bp_list = target->GetBreakpointList();
                const size_t num_bps = bp_list.GetSize();
                for (size_t bp_idx=0; bp_idx<num_bps; ++bp_idx)
                {
                    BreakpointSP bp_sp = bp_list.GetBreakpointAtIndex(bp_idx);
                    const size_t num_bps_locs = bp_sp->GetNumLocations();
                    for (size_t bp_loc_idx=0; bp_loc_idx<num_bps_locs; ++bp_loc_idx)
                    {
                        BreakpointLocationSP bp_loc_sp = bp_sp->GetLocationAtIndex(bp_loc_idx);
                        LineEntry bp_loc_line_entry;
                        if (bp_loc_sp->GetAddress().CalculateSymbolContextLineEntry (bp_loc_line_entry))
                        {
                            if (m_file_sp->GetFileSpec() == bp_loc_line_entry.file)
                            {
                                bp_lines.insert(bp_loc_line_entry.line);
                            }
                        }
                    }
                }
            }

            const attr_t selected_highlight_attr = A_REVERSE;
            const attr_t pc_highlight_attr = COLOR_PAIR(1);

            for (size_t i=0; i<num_visible_lines; ++i)
            {
                const uint32_t curr_line = m_first_visible_line + i;
                if (curr_line < num_source_lines)
                {
                    const int line_y = m_min_y+i;
                    window.MoveCursor(1, line_y);
                    const bool is_pc_line = curr_line == m_pc_line;
                    const bool line_is_selected = m_selected_line == curr_line;
                    // Highlight the line as the PC line first, then if the selected line
                    // isn't the same as the PC line, highlight it differently
                    attr_t highlight_attr = 0;
                    attr_t bp_attr = 0;
                    if (is_pc_line)
                        highlight_attr = pc_highlight_attr;
                    else if (line_is_selected)
                        highlight_attr = selected_highlight_attr;

                    if (bp_lines.find(curr_line+1) != bp_lines.end())
                        bp_attr = COLOR_PAIR(2);

                    if (bp_attr)
                        window.AttributeOn(bp_attr);

                    window.Printf (m_line_format, curr_line + 1);

                    if (bp_attr)
                        window.AttributeOff(bp_attr);

                    window.PutChar(ACS_VLINE);
                    // Mark the line with the PC with a diamond
                    if (is_pc_line)
                        window.PutChar(ACS_DIAMOND);
                    else
                        window.PutChar(' ');

                    if (highlight_attr)
                        window.AttributeOn(highlight_attr);
                    const uint32_t line_len = m_file_sp->GetLineLength(curr_line + 1, false);
                    if (line_len > 0)
                        window.PutCString(m_file_sp->PeekLineData(curr_line + 1), line_len);

                    if (is_pc_line && frame_sp && frame_sp->GetConcreteFrameIndex() == 0)
                    {
                        StopInfoSP stop_info_sp;
                        if (thread)
                            stop_info_sp = thread->GetStopInfo();
                        if (stop_info_sp)
                        {
                            const char *stop_description = stop_info_sp->GetDescription();
                            if (stop_description && stop_description[0])
                            {
                                size_t stop_description_len = strlen(stop_description);
                                int desc_x = window_width - stop_description_len - 16;
                                window.Printf ("%*s", desc_x - window.GetCursorX(), "");
                                //window.MoveCursor(window_width - stop_description_len - 15, line_y);
                                window.Printf ("<<< Thread %u: %s ", thread->GetIndexID(), stop_description);
                            }
                        }
                        else
                        {
                            window.Printf ("%*s", window_width - window.GetCursorX() - 1, "");
                        }
                    }
                    if (highlight_attr)
                        window.AttributeOff(highlight_attr);
                }
                else
                {
                    break;
                }
            }
        }
        else
        {
            size_t num_disassembly_lines = GetNumDisassemblyLines();
            if (num_disassembly_lines > 0)
            {
                // Display disassembly
                BreakpointAddrs bp_file_addrs;
                Target *target = exe_ctx.GetTargetPtr();
                if (target)
                {
                    BreakpointList &bp_list = target->GetBreakpointList();
                    const size_t num_bps = bp_list.GetSize();
                    for (size_t bp_idx=0; bp_idx<num_bps; ++bp_idx)
                    {
                        BreakpointSP bp_sp = bp_list.GetBreakpointAtIndex(bp_idx);
                        const size_t num_bps_locs = bp_sp->GetNumLocations();
                        for (size_t bp_loc_idx=0; bp_loc_idx<num_bps_locs; ++bp_loc_idx)
                        {
                            BreakpointLocationSP bp_loc_sp = bp_sp->GetLocationAtIndex(bp_loc_idx);
                            LineEntry bp_loc_line_entry;
                            const lldb::addr_t file_addr = bp_loc_sp->GetAddress().GetFileAddress();
                            if (file_addr != LLDB_INVALID_ADDRESS)
                            {
                                if (m_disassembly_range.ContainsFileAddress(file_addr))
                                    bp_file_addrs.insert(file_addr);
                            }
                        }
                    }
                }

                const attr_t selected_highlight_attr = A_REVERSE;
                const attr_t pc_highlight_attr = COLOR_PAIR(1);

                StreamString strm;

                InstructionList &insts = m_disassembly_sp->GetInstructionList();
                Address pc_address;

                if (frame_sp)
                    pc_address = frame_sp->GetFrameCodeAddress();
                const uint32_t pc_idx = pc_address.IsValid() ? insts.GetIndexOfInstructionAtAddress (pc_address) : UINT32_MAX;
                if (set_selected_line_to_pc)
                {
                    m_selected_line = pc_idx;
                }

                const uint32_t non_visible_pc_offset = (num_visible_lines / 5);
                if (static_cast<size_t>(m_first_visible_line) >= num_disassembly_lines)
                    m_first_visible_line = 0;

                if (pc_idx < num_disassembly_lines)
                {
                    if (pc_idx < static_cast<uint32_t>(m_first_visible_line) ||
                        pc_idx >= m_first_visible_line + num_visible_lines)
                        m_first_visible_line = pc_idx - non_visible_pc_offset;
                }

                for (size_t i=0; i<num_visible_lines; ++i)
                {
                    const uint32_t inst_idx = m_first_visible_line + i;
                    Instruction *inst = insts.GetInstructionAtIndex(inst_idx).get();
                    if (!inst)
                        break;

                    const int line_y = m_min_y+i;
                    window.MoveCursor(1, line_y);
                    const bool is_pc_line = frame_sp && inst_idx == pc_idx;
                    const bool line_is_selected = m_selected_line == inst_idx;
                    // Highlight the line as the PC line first, then if the selected line
                    // isn't the same as the PC line, highlight it differently
                    attr_t highlight_attr = 0;
                    attr_t bp_attr = 0;
                    if (is_pc_line)
                        highlight_attr = pc_highlight_attr;
                    else if (line_is_selected)
                        highlight_attr = selected_highlight_attr;

                    if (bp_file_addrs.find(inst->GetAddress().GetFileAddress()) != bp_file_addrs.end())
                        bp_attr = COLOR_PAIR(2);

                    if (bp_attr)
                        window.AttributeOn(bp_attr);

                    window.Printf (" 0x%16.16llx ",
                                   static_cast<unsigned long long>(inst->GetAddress().GetLoadAddress(target)));

                    if (bp_attr)
                        window.AttributeOff(bp_attr);

                    window.PutChar(ACS_VLINE);
                    // Mark the line with the PC with a diamond
                    if (is_pc_line)
                        window.PutChar(ACS_DIAMOND);
                    else
                        window.PutChar(' ');

                    if (highlight_attr)
                        window.AttributeOn(highlight_attr);

                    const char *mnemonic = inst->GetMnemonic(&exe_ctx);
                    const char *operands = inst->GetOperands(&exe_ctx);
                    const char *comment = inst->GetComment(&exe_ctx);

                    if (mnemonic && mnemonic[0] == '\0')
                        mnemonic = NULL;
                    if (operands && operands[0] == '\0')
                        operands = NULL;
                    if (comment && comment[0] == '\0')
                        comment = NULL;

                    strm.Clear();

                    if (mnemonic && operands && comment)
                        strm.Printf ("%-8s %-25s ; %s", mnemonic, operands, comment);
                    else if (mnemonic && operands)
                        strm.Printf ("%-8s %s", mnemonic, operands);
                    else if (mnemonic)
                        strm.Printf ("%s", mnemonic);

                    int right_pad = 1;
                    window.PutCStringTruncated(strm.GetString().c_str(), right_pad);

                    if (is_pc_line && frame_sp && frame_sp->GetConcreteFrameIndex() == 0)
                    {
                        StopInfoSP stop_info_sp;
                        if (thread)
                            stop_info_sp = thread->GetStopInfo();
                        if (stop_info_sp)
                        {
                            const char *stop_description = stop_info_sp->GetDescription();
                            if (stop_description && stop_description[0])
                            {
                                size_t stop_description_len = strlen(stop_description);
                                int desc_x = window_width - stop_description_len - 16;
                                window.Printf ("%*s", desc_x - window.GetCursorX(), "");
                                //window.MoveCursor(window_width - stop_description_len - 15, line_y);
                                window.Printf ("<<< Thread %u: %s ", thread->GetIndexID(), stop_description);
                            }
                        }
                        else
                        {
                            window.Printf ("%*s", window_width - window.GetCursorX() - 1, "");
                        }
                    }
                    if (highlight_attr)
                        window.AttributeOff(highlight_attr);
                }
            }
        }
        window.DeferredRefresh();
        return true; // Drawing handled
    }

    size_t
    GetNumLines ()
    {
        size_t num_lines = GetNumSourceLines();
        if (num_lines == 0)
            num_lines = GetNumDisassemblyLines();
        return num_lines;
    }

    size_t
    GetNumSourceLines () const
    {
        if (m_file_sp)
            return m_file_sp->GetNumLines();
        return 0;
    }

    size_t
    GetNumDisassemblyLines () const
    {
        if (m_disassembly_sp)
            return m_disassembly_sp->GetInstructionList().GetSize();
        return 0;
    }

    HandleCharResult
    WindowDelegateHandleChar (Window &window, int c) override
    {
        const uint32_t num_visible_lines = NumVisibleLines();
        const size_t num_lines = GetNumLines ();

        switch (c)
        {
            case ',':
            case KEY_PPAGE:
                // Page up key
                if (static_cast<uint32_t>(m_first_visible_line) > num_visible_lines)
                    m_first_visible_line -= num_visible_lines;
                else
                    m_first_visible_line = 0;
                m_selected_line = m_first_visible_line;
                return eKeyHandled;

            case '.':
            case KEY_NPAGE:
                // Page down key
                {
                    if (m_first_visible_line + num_visible_lines < num_lines)
                        m_first_visible_line += num_visible_lines;
                    else if (num_lines < num_visible_lines)
                        m_first_visible_line = 0;
                    else
                        m_first_visible_line = num_lines - num_visible_lines;
                    m_selected_line = m_first_visible_line;
                }
                return eKeyHandled;

            case KEY_UP:
                if (m_selected_line > 0)
                {
                    m_selected_line--;
                    if (static_cast<size_t>(m_first_visible_line) > m_selected_line)
                        m_first_visible_line = m_selected_line;
                }
                return eKeyHandled;

            case KEY_DOWN:
                if (m_selected_line + 1 < num_lines)
                {
                    m_selected_line++;
                    if (m_first_visible_line + num_visible_lines < m_selected_line)
                        m_first_visible_line++;
                }
                return eKeyHandled;

            case '\r':
            case '\n':
            case KEY_ENTER:
                // Set a breakpoint and run to the line using a one shot breakpoint
                if (GetNumSourceLines() > 0)
                {
                    ExecutionContext exe_ctx = m_debugger.GetCommandInterpreter().GetExecutionContext();
                    if (exe_ctx.HasProcessScope() && exe_ctx.GetProcessRef().IsAlive())
                    {
                        BreakpointSP bp_sp = exe_ctx.GetTargetRef().CreateBreakpoint (NULL,                      // Don't limit the breakpoint to certain modules
                                                                                      m_file_sp->GetFileSpec(),  // Source file
                                                                                      m_selected_line + 1,       // Source line number (m_selected_line is zero based)
                                                                                      0,                         // No offset
                                                                                      eLazyBoolCalculate,        // Check inlines using global setting
                                                                                      eLazyBoolCalculate,        // Skip prologue using global setting,
                                                                                      false,                     // internal
                                                                                      false,                     // request_hardware
                                                                                      eLazyBoolCalculate);       // move_to_nearest_code
                        // Make breakpoint one shot
                        bp_sp->GetOptions()->SetOneShot(true);
                        exe_ctx.GetProcessRef().Resume();
                    }
                }
                else if (m_selected_line < GetNumDisassemblyLines())
                {
                    const Instruction *inst = m_disassembly_sp->GetInstructionList().GetInstructionAtIndex(m_selected_line).get();
                    ExecutionContext exe_ctx = m_debugger.GetCommandInterpreter().GetExecutionContext();
                    if (exe_ctx.HasTargetScope())
                    {
                        Address addr = inst->GetAddress();
                        BreakpointSP bp_sp = exe_ctx.GetTargetRef().CreateBreakpoint (addr,     // lldb_private::Address
                                                                                      false,    // internal
                                                                                      false);   // request_hardware
                        // Make breakpoint one shot
                        bp_sp->GetOptions()->SetOneShot(true);
                        exe_ctx.GetProcessRef().Resume();
                    }
                }
                return eKeyHandled;

            case 'b':   // 'b' == toggle breakpoint on currently selected line
                if (m_selected_line < GetNumSourceLines())
                {
                    ExecutionContext exe_ctx = m_debugger.GetCommandInterpreter().GetExecutionContext();
                    if (exe_ctx.HasTargetScope())
                    {
                        BreakpointSP bp_sp = exe_ctx.GetTargetRef().CreateBreakpoint (NULL,                      // Don't limit the breakpoint to certain modules
                                                                                      m_file_sp->GetFileSpec(),  // Source file
                                                                                      m_selected_line + 1,       // Source line number (m_selected_line is zero based)
                                                                                      0,                         // No offset
                                                                                      eLazyBoolCalculate,        // Check inlines using global setting
                                                                                      eLazyBoolCalculate,        // Skip prologue using global setting,
                                                                                      false,                     // internal
                                                                                      false,                     // request_hardware
                                                                                      eLazyBoolCalculate);       // move_to_nearest_code
                    }
                }
                else if (m_selected_line < GetNumDisassemblyLines())
                {
                    const Instruction *inst = m_disassembly_sp->GetInstructionList().GetInstructionAtIndex(m_selected_line).get();
                    ExecutionContext exe_ctx = m_debugger.GetCommandInterpreter().GetExecutionContext();
                    if (exe_ctx.HasTargetScope())
                    {
                        Address addr = inst->GetAddress();
                        BreakpointSP bp_sp = exe_ctx.GetTargetRef().CreateBreakpoint (addr,     // lldb_private::Address
                                                                                      false,    // internal
                                                                                      false);   // request_hardware
                    }
                }
                return eKeyHandled;

            case 'd':   // 'd' == detach and let run
            case 'D':   // 'D' == detach and keep stopped
                {
                    ExecutionContext exe_ctx = m_debugger.GetCommandInterpreter().GetExecutionContext();
                    if (exe_ctx.HasProcessScope())
                        exe_ctx.GetProcessRef().Detach(c == 'D');
                }
                return eKeyHandled;

            case 'k':
                // 'k' == kill
                {
                    ExecutionContext exe_ctx = m_debugger.GetCommandInterpreter().GetExecutionContext();
                    if (exe_ctx.HasProcessScope())
                        exe_ctx.GetProcessRef().Destroy(false);
                }
                return eKeyHandled;

            case 'c':
                // 'c' == continue
                {
                    ExecutionContext exe_ctx = m_debugger.GetCommandInterpreter().GetExecutionContext();
                    if (exe_ctx.HasProcessScope())
                        exe_ctx.GetProcessRef().Resume();
                }
                return eKeyHandled;

            case 'o':
                // 'o' == step out
                {
                    ExecutionContext exe_ctx = m_debugger.GetCommandInterpreter().GetExecutionContext();
                    if (exe_ctx.HasThreadScope() && StateIsStoppedState (exe_ctx.GetProcessRef().GetState(), true))
                    {
                        exe_ctx.GetThreadRef().StepOut();
                    }
                }
                return eKeyHandled;

            case 'n':   // 'n' == step over
            case 'N':   // 'N' == step over instruction
                {
                    ExecutionContext exe_ctx = m_debugger.GetCommandInterpreter().GetExecutionContext();
                    if (exe_ctx.HasThreadScope() && StateIsStoppedState (exe_ctx.GetProcessRef().GetState(), true))
                    {
                        bool source_step = (c == 'n');
                        exe_ctx.GetThreadRef().StepOver(source_step);
                    }
                }
                return eKeyHandled;

            case 's':   // 's' == step into
            case 'S':   // 'S' == step into instruction
                {
                    ExecutionContext exe_ctx = m_debugger.GetCommandInterpreter().GetExecutionContext();
                    if (exe_ctx.HasThreadScope() && StateIsStoppedState (exe_ctx.GetProcessRef().GetState(), true))
                    {
                        bool source_step = (c == 's');
                        exe_ctx.GetThreadRef().StepIn(source_step);
                    }
                }
                return eKeyHandled;

            case 'h':
                window.CreateHelpSubwindow ();
                return eKeyHandled;

            default:
                break;
        }
        return eKeyNotHandled;
    }

protected:
    typedef std::set<uint32_t> BreakpointLines;
    typedef std::set<lldb::addr_t> BreakpointAddrs;

    Debugger &m_debugger;
    SymbolContext m_sc;
    SourceManager::FileSP m_file_sp;
    SymbolContextScope *m_disassembly_scope;
    lldb::DisassemblerSP m_disassembly_sp;
    AddressRange m_disassembly_range;
    StreamString m_title;
    lldb::user_id_t m_tid;
    char m_line_format[8];
    int m_line_width;
    uint32_t m_selected_line;       // The selected line
    uint32_t m_pc_line;             // The line with the PC
    uint32_t m_stop_id;
    uint32_t m_frame_idx;
    int m_first_visible_line;
    int m_min_x;
    int m_min_y;
    int m_max_x;
    int m_max_y;
};

DisplayOptions ValueObjectListDelegate::g_options = { true };

IOHandlerCursesGUI::IOHandlerCursesGUI (Debugger &debugger) :
    IOHandler (debugger, IOHandler::Type::Curses)
{
}

void
IOHandlerCursesGUI::Activate ()
{
    IOHandler::Activate();
    if (!m_app_ap)
    {
        m_app_ap.reset (new Application (GetInputFILE(), GetOutputFILE()));

        // This is both a window and a menu delegate
        std::shared_ptr<ApplicationDelegate> app_delegate_sp(new ApplicationDelegate(*m_app_ap, m_debugger));
        
        MenuDelegateSP app_menu_delegate_sp = std::static_pointer_cast<MenuDelegate>(app_delegate_sp);
        MenuSP lldb_menu_sp(new Menu("LLDB" , "F1", KEY_F(1), ApplicationDelegate::eMenuID_LLDB));
        MenuSP exit_menuitem_sp(new Menu("Exit", NULL, 'x', ApplicationDelegate::eMenuID_LLDBExit));
        exit_menuitem_sp->SetCannedResult(MenuActionResult::Quit);
        lldb_menu_sp->AddSubmenu (MenuSP (new Menu("About LLDB", NULL, 'a', ApplicationDelegate::eMenuID_LLDBAbout)));
        lldb_menu_sp->AddSubmenu (MenuSP (new Menu(Menu::Type::Separator)));
        lldb_menu_sp->AddSubmenu (exit_menuitem_sp);
        
        MenuSP target_menu_sp(new Menu("Target" ,"F2", KEY_F(2), ApplicationDelegate::eMenuID_Target));
        target_menu_sp->AddSubmenu (MenuSP (new Menu("Create", NULL, 'c', ApplicationDelegate::eMenuID_TargetCreate)));
        target_menu_sp->AddSubmenu (MenuSP (new Menu("Delete", NULL, 'd', ApplicationDelegate::eMenuID_TargetDelete)));
        
        MenuSP process_menu_sp(new Menu("Process", "F3", KEY_F(3), ApplicationDelegate::eMenuID_Process));
        process_menu_sp->AddSubmenu (MenuSP (new Menu("Attach"  , NULL, 'a', ApplicationDelegate::eMenuID_ProcessAttach)));
        process_menu_sp->AddSubmenu (MenuSP (new Menu("Detach"  , NULL, 'd', ApplicationDelegate::eMenuID_ProcessDetach)));
        process_menu_sp->AddSubmenu (MenuSP (new Menu("Launch"  , NULL, 'l', ApplicationDelegate::eMenuID_ProcessLaunch)));
        process_menu_sp->AddSubmenu (MenuSP (new Menu(Menu::Type::Separator)));
        process_menu_sp->AddSubmenu (MenuSP (new Menu("Continue", NULL, 'c', ApplicationDelegate::eMenuID_ProcessContinue)));
        process_menu_sp->AddSubmenu (MenuSP (new Menu("Halt"    , NULL, 'h', ApplicationDelegate::eMenuID_ProcessHalt)));
        process_menu_sp->AddSubmenu (MenuSP (new Menu("Kill"    , NULL, 'k', ApplicationDelegate::eMenuID_ProcessKill)));
        
        MenuSP thread_menu_sp(new Menu("Thread", "F4", KEY_F(4), ApplicationDelegate::eMenuID_Thread));
        thread_menu_sp->AddSubmenu (MenuSP (new Menu("Step In"  , NULL, 'i', ApplicationDelegate::eMenuID_ThreadStepIn)));
        thread_menu_sp->AddSubmenu (MenuSP (new Menu("Step Over", NULL, 'v', ApplicationDelegate::eMenuID_ThreadStepOver)));
        thread_menu_sp->AddSubmenu (MenuSP (new Menu("Step Out" , NULL, 'o', ApplicationDelegate::eMenuID_ThreadStepOut)));
        
        MenuSP view_menu_sp(new Menu("View", "F5", KEY_F(5), ApplicationDelegate::eMenuID_View));
        view_menu_sp->AddSubmenu (MenuSP (new Menu("Backtrace", NULL, 'b', ApplicationDelegate::eMenuID_ViewBacktrace)));
        view_menu_sp->AddSubmenu (MenuSP (new Menu("Registers", NULL, 'r', ApplicationDelegate::eMenuID_ViewRegisters)));
        view_menu_sp->AddSubmenu (MenuSP (new Menu("Source"   , NULL, 's', ApplicationDelegate::eMenuID_ViewSource)));
        view_menu_sp->AddSubmenu (MenuSP (new Menu("Variables", NULL, 'v', ApplicationDelegate::eMenuID_ViewVariables)));
        
        MenuSP help_menu_sp(new Menu("Help", "F6", KEY_F(6), ApplicationDelegate::eMenuID_Help));
        help_menu_sp->AddSubmenu (MenuSP (new Menu("GUI Help", NULL, 'g', ApplicationDelegate::eMenuID_HelpGUIHelp)));
        
        m_app_ap->Initialize();
        WindowSP &main_window_sp = m_app_ap->GetMainWindow();
        
        MenuSP menubar_sp(new Menu(Menu::Type::Bar));
        menubar_sp->AddSubmenu (lldb_menu_sp);
        menubar_sp->AddSubmenu (target_menu_sp);
        menubar_sp->AddSubmenu (process_menu_sp);
        menubar_sp->AddSubmenu (thread_menu_sp);
        menubar_sp->AddSubmenu (view_menu_sp);
        menubar_sp->AddSubmenu (help_menu_sp);
        menubar_sp->SetDelegate(app_menu_delegate_sp);
        
        Rect content_bounds = main_window_sp->GetFrame();
        Rect menubar_bounds = content_bounds.MakeMenuBar();
        Rect status_bounds = content_bounds.MakeStatusBar();
        Rect source_bounds;
        Rect variables_bounds;
        Rect threads_bounds;
        Rect source_variables_bounds;
        content_bounds.VerticalSplitPercentage(0.80, source_variables_bounds, threads_bounds);
        source_variables_bounds.HorizontalSplitPercentage(0.70, source_bounds, variables_bounds);
        
        WindowSP menubar_window_sp = main_window_sp->CreateSubWindow("Menubar", menubar_bounds, false);
        // Let the menubar get keys if the active window doesn't handle the
        // keys that are typed so it can respond to menubar key presses.
        menubar_window_sp->SetCanBeActive(false); // Don't let the menubar become the active window
        menubar_window_sp->SetDelegate(menubar_sp);
        
        WindowSP source_window_sp (main_window_sp->CreateSubWindow("Source",
                                                                   source_bounds,
                                                                   true));
        WindowSP variables_window_sp (main_window_sp->CreateSubWindow("Variables",
                                                                      variables_bounds,
                                                                      false));
        WindowSP threads_window_sp (main_window_sp->CreateSubWindow("Threads",
                                                                      threads_bounds,
                                                                      false));
        WindowSP status_window_sp (main_window_sp->CreateSubWindow("Status",
                                                                   status_bounds,
                                                                   false));
        status_window_sp->SetCanBeActive(false); // Don't let the status bar become the active window
        main_window_sp->SetDelegate (std::static_pointer_cast<WindowDelegate>(app_delegate_sp));
        source_window_sp->SetDelegate (WindowDelegateSP(new SourceFileWindowDelegate(m_debugger)));
        variables_window_sp->SetDelegate (WindowDelegateSP(new FrameVariablesWindowDelegate(m_debugger)));
        TreeDelegateSP thread_delegate_sp (new ThreadsTreeDelegate(m_debugger));
        threads_window_sp->SetDelegate (WindowDelegateSP(new TreeWindowDelegate(m_debugger, thread_delegate_sp)));
        status_window_sp->SetDelegate (WindowDelegateSP(new StatusBarWindowDelegate(m_debugger)));

        // Show the main help window once the first time the curses GUI is launched
        static bool g_showed_help = false;
        if (!g_showed_help)
        {
            g_showed_help = true;
            main_window_sp->CreateHelpSubwindow();
        }

        init_pair (1, COLOR_WHITE   , COLOR_BLUE  );
        init_pair (2, COLOR_BLACK   , COLOR_WHITE );
        init_pair (3, COLOR_MAGENTA , COLOR_WHITE );
        init_pair (4, COLOR_MAGENTA , COLOR_BLACK );
        init_pair (5, COLOR_RED     , COLOR_BLACK );
    }
}

void
IOHandlerCursesGUI::Deactivate ()
{
    m_app_ap->Terminate();
}

void
IOHandlerCursesGUI::Run ()
{
    m_app_ap->Run(m_debugger);
    SetIsDone(true);
}

IOHandlerCursesGUI::~IOHandlerCursesGUI() = default;

void
IOHandlerCursesGUI::Cancel ()
{
}

bool
IOHandlerCursesGUI::Interrupt ()
{
    return false;
}

void
IOHandlerCursesGUI::GotEOF()
{
}

#endif // LLDB_DISABLE_CURSES