src/chat.h

   1 /*
   2 Minetest
   3 Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU Lesser General Public License as published by
   7 the Free Software Foundation; either version 2.1 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU Lesser General Public License for more details.
  14
  15 You should have received a copy of the GNU Lesser General Public License along
  16 with this program; if not, write to the Free Software Foundation, Inc.,
  17 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 */
  19
  20 #pragma once
  21
  22 #include <string>
  23 #include <vector>
  24 #include <list>
  25
  26 #include "irrlichttypes.h"
  27 #include "util/enriched_string.h"
  28 #include "settings.h"
  29
  30 // Chat console related classes
  31
  32 struct ChatLine
  33 {
  34         // age in seconds
  35         f32 age = 0.0f;
  36         // name of sending player, or empty if sent by server
  37         EnrichedString name;
  38         // message text
  39         EnrichedString text;
  40
  41         ChatLine(const std::wstring &a_name, const std::wstring &a_text):
  42                 name(a_name),
  43                 text(a_text)
  44         {
  45         }
  46
  47         ChatLine(const EnrichedString &a_name, const EnrichedString &a_text):
  48                 name(a_name),
  49                 text(a_text)
  50         {
  51         }
  52 };
  53
  54 struct ChatFormattedFragment
  55 {
  56         // text string
  57         EnrichedString text;
  58         // starting column
  59         u32 column;
  60         // formatting
  61         //u8 bold:1;
  62 };
  63
  64 struct ChatFormattedLine
  65 {
  66         // Array of text fragments
  67         std::vector<ChatFormattedFragment> fragments;
  68         // true if first line of one formatted ChatLine
  69         bool first;
  70 };
  71
  72 class ChatBuffer
  73 {
  74 public:
  75         ChatBuffer(u32 scrollback);
  76         ~ChatBuffer() = default;
  77
  78         // Append chat line
  79         // Removes oldest chat line if scrollback size is reached
  80         void addLine(const std::wstring &name, const std::wstring &text);
  81
  82         // Remove all chat lines
  83         void clear();
  84
  85         // Get number of lines currently in buffer.
  86         u32 getLineCount() const;
  87         // Get reference to i-th chat line.
  88         const ChatLine& getLine(u32 index) const;
  89
  90         // Increase each chat line's age by dtime.
  91         void step(f32 dtime);
  92         // Delete oldest N chat lines.
  93         void deleteOldest(u32 count);
  94         // Delete lines older than maxAge.
  95         void deleteByAge(f32 maxAge);
  96
  97         // Get number of columns, 0 if reformat has not been called yet.
  98         u32 getColumns() const;
  99         // Get number of rows, 0 if reformat has not been called yet.
 100         u32 getRows() const;
 101         // Update console size and reformat all formatted lines.
 102         void reformat(u32 cols, u32 rows);
 103         // Get formatted line for a given row (0 is top of screen).
 104         // Only valid after reformat has been called at least once
 105         const ChatFormattedLine& getFormattedLine(u32 row) const;
 106         // Scrolling in formatted buffer (relative)
 107         // positive rows == scroll up, negative rows == scroll down
 108         void scroll(s32 rows);
 109         // Scrolling in formatted buffer (absolute)
 110         void scrollAbsolute(s32 scroll);
 111         // Scroll to bottom of buffer (newest)
 112         void scrollBottom();
 113         // Scroll to top of buffer (oldest)
 114         void scrollTop();
 115
 116         // Format a chat line for the given number of columns.
 117         // Appends the formatted lines to the destination array and
 118         // returns the number of formatted lines.
 119         u32 formatChatLine(const ChatLine& line, u32 cols,
 120                         std::vector<ChatFormattedLine>& destination) const;
 121
 122         void resize(u32 scrollback);
 123 protected:
 124         s32 getTopScrollPos() const;
 125         s32 getBottomScrollPos() const;
 126
 127 private:
 128         // Scrollback size
 129         u32 m_scrollback;
 130         // Array of unformatted chat lines
 131         std::vector<ChatLine> m_unformatted;
 132
 133         // Number of character columns in console
 134         u32 m_cols = 0;
 135         // Number of character rows in console
 136         u32 m_rows = 0;
 137         // Scroll position (console's top line index into m_formatted)
 138         s32 m_scroll = 0;
 139         // Array of formatted lines
 140         std::vector<ChatFormattedLine> m_formatted;
 141         // Empty formatted line, for error returns
 142         ChatFormattedLine m_empty_formatted_line;
 143 };
 144
 145 class ChatPrompt
 146 {
 147 public:
 148         ChatPrompt(const std::wstring &prompt, u32 history_limit);
 149         ~ChatPrompt() = default;
 150
 151         // Input character or string
 152         void input(wchar_t ch);
 153         void input(const std::wstring &str);
 154
 155         // Add a string to the history
 156         void addToHistory(const std::wstring &line);
 157
 158         // Get current line
 159         std::wstring getLine() const { return m_line; }
 160
 161         // Get section of line that is currently selected
 162         std::wstring getSelection() const { return m_line.substr(m_cursor, m_cursor_len); }
 163
 164         // Clear the current line
 165         void clear();
 166
 167         // Replace the current line with the given text
 168         std::wstring replace(const std::wstring &line);
 169
 170         // Select previous command from history
 171         void historyPrev();
 172         // Select next command from history
 173         void historyNext();
 174
 175         // Nick completion
 176         void nickCompletion(const std::list<std::string>& names, bool backwards);
 177
 178         // Update console size and reformat the visible portion of the prompt
 179         void reformat(u32 cols);
 180         // Get visible portion of the prompt.
 181         std::wstring getVisiblePortion() const;
 182         // Get cursor position (relative to visible portion). -1 if invalid
 183         s32 getVisibleCursorPosition() const;
 184         // Get length of cursor selection
 185         s32 getCursorLength() const { return m_cursor_len; }
 186
 187         // Cursor operations
 188         enum CursorOp {
 189                 CURSOROP_MOVE,
 190                 CURSOROP_SELECT,
 191                 CURSOROP_DELETE
 192         };
 193
 194         // Cursor operation direction
 195         enum CursorOpDir {
 196                 CURSOROP_DIR_LEFT,
 197                 CURSOROP_DIR_RIGHT
 198         };
 199
 200         // Cursor operation scope
 201         enum CursorOpScope {
 202                 CURSOROP_SCOPE_CHARACTER,
 203                 CURSOROP_SCOPE_WORD,
 204                 CURSOROP_SCOPE_LINE,
 205                 CURSOROP_SCOPE_SELECTION
 206         };
 207
 208         // Cursor operation
 209         // op specifies whether it's a move or delete operation
 210         // dir specifies whether the operation goes left or right
 211         // scope specifies how far the operation will reach (char/word/line)
 212         // Examples:
 213         //   cursorOperation(CURSOROP_MOVE, CURSOROP_DIR_RIGHT, CURSOROP_SCOPE_LINE)
 214         //     moves the cursor to the end of the line.
 215         //   cursorOperation(CURSOROP_DELETE, CURSOROP_DIR_LEFT, CURSOROP_SCOPE_WORD)
 216         //     deletes the word to the left of the cursor.
 217         void cursorOperation(CursorOp op, CursorOpDir dir, CursorOpScope scope);
 218
 219 protected:
 220         // set m_view to ensure that 0 <= m_view <= m_cursor < m_view + m_cols
 221         // if line can be fully shown, set m_view to zero
 222         // else, also ensure m_view <= m_line.size() + 1 - m_cols
 223         void clampView();
 224
 225 private:
 226         // Prompt prefix
 227         std::wstring m_prompt = L"";
 228         // Currently edited line
 229         std::wstring m_line = L"";
 230         // History buffer
 231         std::vector<std::wstring> m_history;
 232         // History index (0 <= m_history_index <= m_history.size())
 233         u32 m_history_index = 0;
 234         // Maximum number of history entries
 235         u32 m_history_limit;
 236
 237         // Number of columns excluding columns reserved for the prompt
 238         s32 m_cols = 0;
 239         // Start of visible portion (index into m_line)
 240         s32 m_view = 0;
 241         // Cursor (index into m_line)
 242         s32 m_cursor = 0;
 243         // Cursor length (length of selected portion of line)
 244         s32 m_cursor_len = 0;
 245
 246         // Last nick completion start (index into m_line)
 247         s32 m_nick_completion_start = 0;
 248         // Last nick completion start (index into m_line)
 249         s32 m_nick_completion_end = 0;
 250 };
 251
 252 class ChatBackend
 253 {
 254 public:
 255         ChatBackend();
 256         ~ChatBackend() = default;
 257
 258         // Add chat message
 259         void addMessage(const std::wstring &name, std::wstring text);
 260         // Parse and add unparsed chat message
 261         void addUnparsedMessage(std::wstring line);
 262
 263         // Get the console buffer
 264         ChatBuffer& getConsoleBuffer();
 265         // Get the recent messages buffer
 266         ChatBuffer& getRecentBuffer();
 267         // Concatenate all recent messages
 268         EnrichedString getRecentChat() const;
 269         // Get the console prompt
 270         ChatPrompt& getPrompt();
 271
 272         // Reformat all buffers
 273         void reformat(u32 cols, u32 rows);
 274
 275         // Clear all recent messages
 276         void clearRecentChat();
 277
 278         // Age recent messages
 279         void step(float dtime);
 280
 281         // Scrolling
 282         void scroll(s32 rows);
 283         void scrollPageDown();
 284         void scrollPageUp();
 285
 286         // Resize recent buffer based on settings
 287         void applySettings();
 288
 289 private:
 290         ChatBuffer m_console_buffer;
 291         ChatBuffer m_recent_buffer;
 292         ChatPrompt m_prompt;
 293 };