Subversion Repositories Games.Descent

/*

 * This file is part of the DXX-Rebirth project <https://www.dxx-rebirth.com/>.

 * It is copyright by its individual contributors, as recorded in the

 * project's Git history.  See COPYING.txt at the top level for license

 * terms and a link to the Git history.

 *

 * --

 *  Based on an early version of SDL_Console

 *  Written By: Garrett Banuk <mongoose@mongeese.org>

 *  Code Cleanup and heavily extended by: Clemens Wacha <reflex-2000@gmx.net>

 *  Ported to use native Descent interfaces by: Bradley Bell <btb@icculus.org>

 *

 *  This is free, just be sure to give us credit when using it

 *  in any of your programs.

 * --

 *

 * Rewritten to use C++ utilities by Kp.  Post-Bradley work is under

 * the standard Rebirth terms, which are less permissive than the

 * statement above.

 */

/*

 *

 * Command-line interface for the console

 *

 */

#include <algorithm>

#include <cassert>

#include <cctype>

#include <deque>

#include <string>

#include "gr.h"

#include "gamefont.h"

#include "console.h"

#include "cli.h"

#include "compiler-poison.h"

// Cursor shown if we are in insert mode

#define CLI_INS_CURSOR          "_"

// Cursor shown if we are in overwrite mode

#define CLI_OVR_CURSOR          "|"

namespace {

class CLIState

{

        static const char g_prompt_mode_cmd = ']';

        static const char g_prompt_strings[];

        /* When drawing an underscore as a cursor indicator, shift it down by

         * this many pixels, to make it easier to see when the underlined

         * character is itself an underscore.

         */

        static const unsigned m_cursor_underline_y_shift = 3;

        static const unsigned m_maximum_history_lines = 100;

        unsigned m_history_position, m_line_position;

        std::string m_line;

        std::deque<std::string> m_lines;

        CLI_insert_type m_insert_type;

        void history_move(unsigned position);

public:

        void init();

        unsigned draw(unsigned, unsigned);

        void execute_active_line();

        void insert_completion();

        void cursor_left();

        void cursor_right();

        void cursor_home();

        void cursor_end();

        void cursor_del();

        void cursor_backspace();

        void add_character(char c);

        void clear_active_line();

        void history_prev();

        void history_next();

        void toggle_overwrite_mode();

};

const char CLIState::g_prompt_strings[] = {

        g_prompt_mode_cmd,

};

}

static CLIState g_cli;

/* Initializes the cli */

void cli_init()

{

        g_cli.init();

}

/* Draws the command line the user is typing in to the screen */

unsigned cli_draw(unsigned y, unsigned line_spacing)

{

        return g_cli.draw(y, line_spacing);

}

/* Executes the command entered */

void cli_execute()

{

        g_cli.execute_active_line();

}

void cli_autocomplete(void)

{

        g_cli.insert_completion();

}

void cli_cursor_left()

{

        g_cli.cursor_left();

}

void cli_cursor_right()

{

        g_cli.cursor_right();

}

void cli_cursor_home()

{

        g_cli.cursor_home();

}

void cli_cursor_end()

{

        g_cli.cursor_end();

}

void cli_cursor_del()

{

        g_cli.cursor_del();

}

void cli_cursor_backspace()

{

        g_cli.cursor_backspace();

}

void cli_add_character(char character)

{

        g_cli.add_character(character);

}

void cli_clear()

{

        g_cli.clear_active_line();

}

void cli_history_prev()

{

        g_cli.history_prev();

}

void cli_history_next()

{

        g_cli.history_next();

}

void cli_toggle_overwrite_mode()

{

        g_cli.toggle_overwrite_mode();

}

void CLIState::init()

{

        m_lines.emplace_front();

}

unsigned CLIState::draw(unsigned y, unsigned line_spacing)

{

        using wrap_result = std::pair<const char *, unsigned>;

        /* At most this many lines of wrapped input can be shown at once.

         * Any excess lines will be hidden.

         *

         * Use a power of 2 to make the modulus optimize into a fast masking

         * operation.

         *

         * Zero-initialize for safety, but also mark it as initially

         * undefined for Valgrind.  Assuming no bugs, any element of wraps[]

         * accessed by the second loop will have been initialized by the

         * first loop.

         */

        std::array<wrap_result, 8> wraps{};

        DXX_MAKE_VAR_UNDEFINED(wraps);

        const auto margin_width = FSPACX(1);

        const char prompt_string[2] = {g_prompt_strings[0], 0};

        int prompt_width, h;

        gr_get_string_size(*grd_curcanv->cv_font, prompt_string, &prompt_width, &h, nullptr);

        y -= line_spacing;

        const auto canvas_width = grd_curcanv->cv_bitmap.bm_w;

        const unsigned max_pixels_per_line = canvas_width - (margin_width * 2) - prompt_width;

        const unsigned unknown_cursor_line = ~0u;

        const auto line_position = m_line_position;

        const auto line_begin = m_line.c_str();

        std::size_t last_wrap_line = 0;

        unsigned cursor_line = unknown_cursor_line;

        /* Search the text and initialize wraps[] to record where line

         * breaks will appear.  If the wrapped text is more than

         * wraps.size() vertical lines, only the most recent wraps.size()

         * lines are saved and shown.

         */

        for (const char *p = line_begin;; ++last_wrap_line)

        {

                auto &w = wraps[last_wrap_line % wraps.size()];

                w = gr_get_string_wrap(*grd_curcanv->cv_font, p, max_pixels_per_line);

                /* Record the vertical line on which the cursor will appear as

                 * `cursor_line`.

                 */

                if (cursor_line == unknown_cursor_line)

                {

                        const auto unseen_position = w.first - p;

                        if (line_position < unseen_position)

                                cursor_line = last_wrap_line;

                }

                /* If more text exists than can be shown, then stop at

                 * (wraps.size() / 2) lines past the cursor line.

                 */

                else if (last_wrap_line >= wraps.size() && cursor_line + (wraps.size() / 2) < last_wrap_line)

                        break;

                p = w.first;

                if (!*p)

                        break;

        }

        const auto line_left = margin_width + prompt_width + 1;

        const auto cursor_string = (m_insert_type == CLI_insert_type::insert ? CLI_INS_CURSOR : CLI_OVR_CURSOR);

        int cursor_width, cursor_height;

        gr_get_string_size(*grd_curcanv->cv_font, cursor_string, &cursor_width, &cursor_height, nullptr);

        if (line_position == m_line.size())

        {

                const auto &w = wraps[last_wrap_line % wraps.size()];

                if (cursor_width + line_left + w.second > max_pixels_per_line)

                {

                        auto &w2 = wraps[++last_wrap_line % wraps.size()];

                        w2 = {w.first, 0};

                        assert(!*w2.first);

                }

                cursor_line = last_wrap_line;

        }

        for (unsigned i = std::min(last_wrap_line + 1, wraps.size());; --last_wrap_line)

        {

                const auto &w = wraps[last_wrap_line % wraps.size()];

                const auto p = w.first;

                if (!p)

                {

                        assert(p);

                        break;

                }

                std::string::const_pointer q;

                if (last_wrap_line)

                {

                        q = wraps[(last_wrap_line - 1) % wraps.size()].first;

                        if (!q)

                        {

                                assert(q);

                                break;

                        }

                }

                else

                        q = line_begin;

                std::string::pointer mc;

                std::string::value_type c;

                /* If the parsing loop exited by the cursor_line test, then this

                 * test is true on every pass through this loop.

                 *

                 * If the parsing loop exited by !*p, then this test is false on

                 * the first pass through this loop and true on every other

                 * pass.

                 *

                 * If the input text requires only one vertical line, then the

                 * parsing loop will have exited through the !*p test and this

                 * loop will only run iteration.

                 */

                if (*p)

                {

                        /* Temporarily write a null into the text string for the

                         * benefit of null-terminator based code in the gr_string*

                         * functions.  The original character is saved in `c` and

                         * will be restored later.

                         */

                        mc = &m_line[p - q];

                        c = *mc;

                        *mc = 0;

                }

                else

                {

                        /* No need to write to the std::string because a

                         * null-terminator is already present.

                         */

                        mc = nullptr;

                        c = 0;

                }

                gr_string(*grd_curcanv, *grd_curcanv->cv_font, line_left, y, q, w.second, h);

                if (--i == cursor_line)

                {

                        unsigned cx = line_left + w.second, cy = y;

                        if (m_insert_type == CLI_insert_type::insert)

                                cy += m_cursor_underline_y_shift;

                        if (line_position != p - line_begin)

                        {

                                int cw;

                                gr_get_string_size(*grd_curcanv->cv_font, &line_begin[line_position], &cw, nullptr, nullptr);

                                cx -= cw;

                        }

                        gr_string(*grd_curcanv, *grd_curcanv->cv_font, cx, cy, cursor_string, cursor_width, cursor_height);

                }

                /* Restore the original character, if one was overwritten. */

                if (mc)

                        *mc = c;

                if (!i)

                        break;

                y -= h;

        }

        gr_string(*grd_curcanv, *grd_curcanv->cv_font, margin_width, y, prompt_string, prompt_width, h);

        return y;

}

void CLIState::execute_active_line()

{

        if (m_line.empty())

                return;

        const char *p = m_line.c_str();

        con_printf(CON_NORMAL, "con%c%s", g_prompt_strings[0], p);

        cmd_append(p);

        m_lines[0] = move(m_line);

        m_lines.emplace_front();

        m_history_position = 0;

        if (m_lines.size() > m_maximum_history_lines)

                m_lines.pop_back();

        clear_active_line();

}

void CLIState::insert_completion()

{

        const auto suggestion = cmd_complete(m_line.c_str());

        if (!suggestion)

                return;

        m_line = suggestion;

        m_line += " ";

        m_line_position = m_line.size();

}

void CLIState::cursor_left()

{

        if (m_line_position > 0)

                -- m_line_position;

}

void CLIState::cursor_right()

{

        if (m_line_position < m_line.size())

                ++ m_line_position;

}

void CLIState::cursor_home()

{

        m_line_position = 0;

}

void CLIState::cursor_end()

{

        m_line_position = m_line.size();

}

void CLIState::cursor_del()

{

        const auto l = m_line_position;

        if (l >= m_line.size())

                return;

        m_line.erase(next(m_line.begin(), l));

}

void CLIState::cursor_backspace()

{

        if (m_line_position <= 0)

                return;

        m_line.erase(next(m_line.begin(), --m_line_position));

}

void CLIState::add_character(char c)

{

        if (m_insert_type == CLI_insert_type::overwrite && m_line_position < m_line.size())

                m_line[m_line_position] = c;

        else

                m_line.insert(next(m_line.begin(), m_line_position), c);

        ++m_line_position;

}

void CLIState::clear_active_line()

{

        m_line_position = 0;

        m_line.clear();

}

void CLIState::history_move(unsigned position)

{

        if (position >= m_lines.size())

                return;

        m_lines[m_history_position] = move(m_line);

        auto &l = m_lines[m_history_position = position];

        m_line_position = l.size();

        m_line = l;

}

void CLIState::history_prev()

{

        history_move(m_history_position + 1);

}

void CLIState::history_next()

{

        const auto max_lines = m_lines.size();

        if (m_history_position > max_lines)

                m_history_position = max_lines;

        history_move(m_history_position - 1);

}

void CLIState::toggle_overwrite_mode()

{

        m_insert_type = m_insert_type == CLI_insert_type::insert

                ? CLI_insert_type::overwrite

                : CLI_insert_type::insert;

}