src/console_gui.cpp

   1 /*
   2  * This file is part of OpenTTD.
   3  * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
   4  * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   5  * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
   6  */
   7
   8 /** @file console_gui.cpp Handling the GUI of the in-game console. */
   9
  10 #include "stdafx.h"
  11 #include "textbuf_type.h"
  12 #include "window_gui.h"
  13 #include "console_gui.h"
  14 #include "console_internal.h"
  15 #include "window_func.h"
  16 #include "string_func.h"
  17 #include "strings_func.h"
  18 #include "gfx_func.h"
  19 #include "settings_type.h"
  20 #include "console_func.h"
  21 #include "rev.h"
  22 #include "video/video_driver.hpp"
  23
  24 #include "widgets/console_widget.h"
  25
  26 #include "table/strings.h"
  27
  28 #include "safeguards.h"
  29
  30 static const uint ICON_HISTORY_SIZE       = 20;
  31 static const uint ICON_LINE_SPACING       =  2;
  32 static const uint ICON_RIGHT_BORDERWIDTH  = 10;
  33 static const uint ICON_BOTTOM_BORDERWIDTH = 12;
  34
  35 /**
  36  * Container for a single line of console output
  37  */
  38 struct IConsoleLine {
  39         static IConsoleLine *front; ///< The front of the console backlog buffer
  40         static int size;            ///< The amount of items in the backlog
  41
  42         IConsoleLine *previous; ///< The previous console message.
  43         char *buffer;           ///< The data to store.
  44         TextColour colour;      ///< The colour of the line.
  45         uint16 time;            ///< The amount of time the line is in the backlog.
  46
  47         /**
  48          * Initialize the console line.
  49          * @param buffer the data to print.
  50          * @param colour the colour of the line.
  51          */
  52         IConsoleLine(char *buffer, TextColour colour) :
  53                         previous(IConsoleLine::front),
  54                         buffer(buffer),
  55                         colour(colour),
  56                         time(0)
  57         {
  58                 IConsoleLine::front = this;
  59                 IConsoleLine::size++;
  60         }
  61
  62         /**
  63          * Clear this console line and any further ones.
  64          */
  65         ~IConsoleLine()
  66         {
  67                 IConsoleLine::size--;
  68                 free(buffer);
  69
  70                 delete previous;
  71         }
  72
  73         /**
  74          * Get the index-ed item in the list.
  75          */
  76         static const IConsoleLine *Get(uint index)
  77         {
  78                 const IConsoleLine *item = IConsoleLine::front;
  79                 while (index != 0 && item != nullptr) {
  80                         index--;
  81                         item = item->previous;
  82                 }
  83
  84                 return item;
  85         }
  86
  87         /**
  88          * Truncate the list removing everything older than/more than the amount
  89          * as specified in the config file.
  90          * As a side effect also increase the time the other lines have been in
  91          * the list.
  92          * @return true if and only if items got removed.
  93          */
  94         static bool Truncate()
  95         {
  96                 IConsoleLine *cur = IConsoleLine::front;
  97                 if (cur == nullptr) return false;
  98
  99                 int count = 1;
 100                 for (IConsoleLine *item = cur->previous; item != nullptr; count++, cur = item, item = item->previous) {
 101                         if (item->time > _settings_client.gui.console_backlog_timeout &&
 102                                         count > _settings_client.gui.console_backlog_length) {
 103                                 delete item;
 104                                 cur->previous = nullptr;
 105                                 return true;
 106                         }
 107
 108                         if (item->time != MAX_UVALUE(uint16)) item->time++;
 109                 }
 110
 111                 return false;
 112         }
 113
 114         /**
 115          * Reset the complete console line backlog.
 116          */
 117         static void Reset()
 118         {
 119                 delete IConsoleLine::front;
 120                 IConsoleLine::front = nullptr;
 121                 IConsoleLine::size = 0;
 122         }
 123 };
 124
 125 /* static */ IConsoleLine *IConsoleLine::front = nullptr;
 126 /* static */ int IConsoleLine::size  = 0;
 127
 128
 129 /* ** main console cmd buffer ** */
 130 static Textbuf _iconsole_cmdline(ICON_CMDLN_SIZE);
 131 static char *_iconsole_history[ICON_HISTORY_SIZE];
 132 static int _iconsole_historypos;
 133 IConsoleModes _iconsole_mode;
 134
 135 /* *************** *
 136  *  end of header  *
 137  * *************** */
 138
 139 static void IConsoleClearCommand()
 140 {
 141         memset(_iconsole_cmdline.buf, 0, ICON_CMDLN_SIZE);
 142         _iconsole_cmdline.chars = _iconsole_cmdline.bytes = 1; // only terminating zero
 143         _iconsole_cmdline.pixels = 0;
 144         _iconsole_cmdline.caretpos = 0;
 145         _iconsole_cmdline.caretxoffs = 0;
 146         SetWindowDirty(WC_CONSOLE, 0);
 147 }
 148
 149 static inline void IConsoleResetHistoryPos()
 150 {
 151         _iconsole_historypos = -1;
 152 }
 153
 154
 155 static const char *IConsoleHistoryAdd(const char *cmd);
 156 static void IConsoleHistoryNavigate(int direction);
 157
 158 static const struct NWidgetPart _nested_console_window_widgets[] = {
 159         NWidget(WWT_EMPTY, INVALID_COLOUR, WID_C_BACKGROUND), SetResize(1, 1),
 160 };
 161
 162 static WindowDesc _console_window_desc(
 163         WDP_MANUAL, nullptr, 0, 0,
 164         WC_CONSOLE, WC_NONE,
 165         0,
 166         _nested_console_window_widgets, lengthof(_nested_console_window_widgets)
 167 );
 168
 169 struct IConsoleWindow : Window
 170 {
 171         static int scroll;
 172         int line_height;   ///< Height of one line of text in the console.
 173         int line_offset;
 174
 175         IConsoleWindow() : Window(&_console_window_desc)
 176         {
 177                 _iconsole_mode = ICONSOLE_OPENED;
 178                 this->line_height = FONT_HEIGHT_NORMAL + ICON_LINE_SPACING;
 179                 this->line_offset = GetStringBoundingBox("] ").width + 5;
 180
 181                 this->InitNested(0);
 182                 ResizeWindow(this, _screen.width, _screen.height / 3);
 183         }
 184
 185         ~IConsoleWindow()
 186         {
 187                 _iconsole_mode = ICONSOLE_CLOSED;
 188                 VideoDriver::GetInstance()->EditBoxLostFocus();
 189         }
 190
 191         /**
 192          * Scroll the content of the console.
 193          * @param amount Number of lines to scroll back.
 194          */
 195         void Scroll(int amount)
 196         {
 197                 int max_scroll = max<int>(0, IConsoleLine::size + 1 - this->height / this->line_height);
 198                 IConsoleWindow::scroll = Clamp<int>(IConsoleWindow::scroll + amount, 0, max_scroll);
 199                 this->SetDirty();
 200         }
 201
 202         void OnPaint() override
 203         {
 204                 const int right = this->width - 5;
 205
 206                 GfxFillRect(0, 0, this->width - 1, this->height - 1, PC_BLACK);
 207                 int ypos = this->height - this->line_height;
 208                 for (const IConsoleLine *print = IConsoleLine::Get(IConsoleWindow::scroll); print != nullptr; print = print->previous) {
 209                         SetDParamStr(0, print->buffer);
 210                         ypos = DrawStringMultiLine(5, right, -this->line_height, ypos, STR_JUST_RAW_STRING, print->colour, SA_LEFT | SA_BOTTOM | SA_FORCE) - ICON_LINE_SPACING;
 211                         if (ypos < 0) break;
 212                 }
 213                 /* If the text is longer than the window, don't show the starting ']' */
 214                 int delta = this->width - this->line_offset - _iconsole_cmdline.pixels - ICON_RIGHT_BORDERWIDTH;
 215                 if (delta > 0) {
 216                         DrawString(5, right, this->height - this->line_height, "]", (TextColour)CC_COMMAND, SA_LEFT | SA_FORCE);
 217                         delta = 0;
 218                 }
 219
 220                 /* If we have a marked area, draw a background highlight. */
 221                 if (_iconsole_cmdline.marklength != 0) GfxFillRect(this->line_offset + delta + _iconsole_cmdline.markxoffs, this->height - this->line_height, this->line_offset + delta + _iconsole_cmdline.markxoffs + _iconsole_cmdline.marklength, this->height - 1, PC_DARK_RED);
 222
 223                 DrawString(this->line_offset + delta, right, this->height - this->line_height, _iconsole_cmdline.buf, (TextColour)CC_COMMAND, SA_LEFT | SA_FORCE);
 224
 225                 if (_focused_window == this && _iconsole_cmdline.caret) {
 226                         DrawString(this->line_offset + delta + _iconsole_cmdline.caretxoffs, right, this->height - this->line_height, "_", TC_WHITE, SA_LEFT | SA_FORCE);
 227                 }
 228         }
 229
 230         void OnHundredthTick() override
 231         {
 232                 if (IConsoleLine::Truncate() &&
 233                                 (IConsoleWindow::scroll > IConsoleLine::size)) {
 234                         IConsoleWindow::scroll = max(0, IConsoleLine::size - (this->height / this->line_height) + 1);
 235                         this->SetDirty();
 236                 }
 237         }
 238
 239         void OnMouseLoop() override
 240         {
 241                 if (_iconsole_cmdline.HandleCaret()) this->SetDirty();
 242         }
 243
 244         EventState OnKeyPress(WChar key, uint16 keycode) override
 245         {
 246                 if (_focused_window != this) return ES_NOT_HANDLED;
 247
 248                 const int scroll_height = (this->height / this->line_height) - 1;
 249                 switch (keycode) {
 250                         case WKC_UP:
 251                                 IConsoleHistoryNavigate(1);
 252                                 this->SetDirty();
 253                                 break;
 254
 255                         case WKC_DOWN:
 256                                 IConsoleHistoryNavigate(-1);
 257                                 this->SetDirty();
 258                                 break;
 259
 260                         case WKC_SHIFT | WKC_PAGEDOWN:
 261                                 this->Scroll(-scroll_height);
 262                                 break;
 263
 264                         case WKC_SHIFT | WKC_PAGEUP:
 265                                 this->Scroll(scroll_height);
 266                                 break;
 267
 268                         case WKC_SHIFT | WKC_DOWN:
 269                                 this->Scroll(-1);
 270                                 break;
 271
 272                         case WKC_SHIFT | WKC_UP:
 273                                 this->Scroll(1);
 274                                 break;
 275
 276                         case WKC_BACKQUOTE:
 277                                 IConsoleSwitch();
 278                                 break;
 279
 280                         case WKC_RETURN: case WKC_NUM_ENTER: {
 281                                 /* We always want the ] at the left side; we always force these strings to be left
 282                                  * aligned anyway. So enforce this in all cases by adding a left-to-right marker,
 283                                  * otherwise it will be drawn at the wrong side with right-to-left texts. */
 284                                 IConsolePrintF(CC_COMMAND, LRM "] %s", _iconsole_cmdline.buf);
 285                                 const char *cmd = IConsoleHistoryAdd(_iconsole_cmdline.buf);
 286                                 IConsoleClearCommand();
 287
 288                                 if (cmd != nullptr) IConsoleCmdExec(cmd);
 289                                 break;
 290                         }
 291
 292                         case WKC_CTRL | WKC_RETURN:
 293                                 _iconsole_mode = (_iconsole_mode == ICONSOLE_FULL) ? ICONSOLE_OPENED : ICONSOLE_FULL;
 294                                 IConsoleResize(this);
 295                                 MarkWholeScreenDirty();
 296                                 break;
 297
 298                         case (WKC_CTRL | 'L'):
 299                                 IConsoleCmdExec("clear");
 300                                 break;
 301
 302                         default:
 303                                 if (_iconsole_cmdline.HandleKeyPress(key, keycode) != HKPR_NOT_HANDLED) {
 304                                         IConsoleWindow::scroll = 0;
 305                                         IConsoleResetHistoryPos();
 306                                         this->SetDirty();
 307                                 } else {
 308                                         return ES_NOT_HANDLED;
 309                                 }
 310                                 break;
 311                 }
 312                 return ES_HANDLED;
 313         }
 314
 315         void InsertTextString(int wid, const char *str, bool marked, const char *caret, const char *insert_location, const char *replacement_end) override
 316         {
 317                 if (_iconsole_cmdline.InsertString(str, marked, caret, insert_location, replacement_end)) {
 318                         IConsoleWindow::scroll = 0;
 319                         IConsoleResetHistoryPos();
 320                         this->SetDirty();
 321                 }
 322         }
 323
 324         const char *GetFocusedText() const override
 325         {
 326                 return _iconsole_cmdline.buf;
 327         }
 328
 329         const char *GetCaret() const override
 330         {
 331                 return _iconsole_cmdline.buf + _iconsole_cmdline.caretpos;
 332         }
 333
 334         const char *GetMarkedText(size_t *length) const override
 335         {
 336                 if (_iconsole_cmdline.markend == 0) return nullptr;
 337
 338                 *length = _iconsole_cmdline.markend - _iconsole_cmdline.markpos;
 339                 return _iconsole_cmdline.buf + _iconsole_cmdline.markpos;
 340         }
 341
 342         Point GetCaretPosition() const override
 343         {
 344                 int delta = min(this->width - this->line_offset - _iconsole_cmdline.pixels - ICON_RIGHT_BORDERWIDTH, 0);
 345                 Point pt = {this->line_offset + delta + _iconsole_cmdline.caretxoffs, this->height - this->line_height};
 346
 347                 return pt;
 348         }
 349
 350         Rect GetTextBoundingRect(const char *from, const char *to) const override
 351         {
 352                 int delta = min(this->width - this->line_offset - _iconsole_cmdline.pixels - ICON_RIGHT_BORDERWIDTH, 0);
 353
 354                 Point p1 = GetCharPosInString(_iconsole_cmdline.buf, from, FS_NORMAL);
 355                 Point p2 = from != to ? GetCharPosInString(_iconsole_cmdline.buf, from) : p1;
 356
 357                 Rect r = {this->line_offset + delta + p1.x, this->height - this->line_height, this->line_offset + delta + p2.x, this->height};
 358                 return r;
 359         }
 360
 361         const char *GetTextCharacterAtPosition(const Point &pt) const override
 362         {
 363                 int delta = min(this->width - this->line_offset - _iconsole_cmdline.pixels - ICON_RIGHT_BORDERWIDTH, 0);
 364
 365                 if (!IsInsideMM(pt.y, this->height - this->line_height, this->height)) return nullptr;
 366
 367                 return GetCharAtPosition(_iconsole_cmdline.buf, pt.x - delta);
 368         }
 369
 370         void OnMouseWheel(int wheel) override
 371         {
 372                 this->Scroll(-wheel);
 373         }
 374
 375         void OnFocus() override
 376         {
 377                 VideoDriver::GetInstance()->EditBoxGainedFocus();
 378         }
 379
 380         void OnFocusLost() override
 381         {
 382                 VideoDriver::GetInstance()->EditBoxLostFocus();
 383         }
 384 };
 385
 386 int IConsoleWindow::scroll = 0;
 387
 388 void IConsoleGUIInit()
 389 {
 390         IConsoleResetHistoryPos();
 391         _iconsole_mode = ICONSOLE_CLOSED;
 392
 393         IConsoleLine::Reset();
 394         memset(_iconsole_history, 0, sizeof(_iconsole_history));
 395
 396         IConsolePrintF(CC_WARNING, "OpenTTD Game Console Revision 7 - %s", _openttd_revision);
 397         IConsolePrint(CC_WHITE,  "------------------------------------");
 398         IConsolePrint(CC_WHITE,  "use \"help\" for more information");
 399         IConsolePrint(CC_WHITE,  "");
 400         IConsoleClearCommand();
 401 }
 402
 403 void IConsoleClearBuffer()
 404 {
 405         IConsoleLine::Reset();
 406 }
 407
 408 void IConsoleGUIFree()
 409 {
 410         IConsoleClearBuffer();
 411 }
 412
 413 /** Change the size of the in-game console window after the screen size changed, or the window state changed. */
 414 void IConsoleResize(Window *w)
 415 {
 416         switch (_iconsole_mode) {
 417                 case ICONSOLE_OPENED:
 418                         w->height = _screen.height / 3;
 419                         w->width = _screen.width;
 420                         break;
 421                 case ICONSOLE_FULL:
 422                         w->height = _screen.height - ICON_BOTTOM_BORDERWIDTH;
 423                         w->width = _screen.width;
 424                         break;
 425                 default: return;
 426         }
 427
 428         MarkWholeScreenDirty();
 429 }
 430
 431 /** Toggle in-game console between opened and closed. */
 432 void IConsoleSwitch()
 433 {
 434         switch (_iconsole_mode) {
 435                 case ICONSOLE_CLOSED:
 436                         new IConsoleWindow();
 437                         break;
 438
 439                 case ICONSOLE_OPENED: case ICONSOLE_FULL:
 440                         DeleteWindowById(WC_CONSOLE, 0);
 441                         break;
 442         }
 443
 444         MarkWholeScreenDirty();
 445 }
 446
 447 /** Close the in-game console. */
 448 void IConsoleClose()
 449 {
 450         if (_iconsole_mode == ICONSOLE_OPENED) IConsoleSwitch();
 451 }
 452
 453 /**
 454  * Add the entered line into the history so you can look it back
 455  * scroll, etc. Put it to the beginning as it is the latest text
 456  * @param cmd Text to be entered into the 'history'
 457  * @return the command to execute
 458  */
 459 static const char *IConsoleHistoryAdd(const char *cmd)
 460 {
 461         /* Strip all spaces at the begin */
 462         while (IsWhitespace(*cmd)) cmd++;
 463
 464         /* Do not put empty command in history */
 465         if (StrEmpty(cmd)) return nullptr;
 466
 467         /* Do not put in history if command is same as previous */
 468         if (_iconsole_history[0] == nullptr || strcmp(_iconsole_history[0], cmd) != 0) {
 469                 free(_iconsole_history[ICON_HISTORY_SIZE - 1]);
 470                 memmove(&_iconsole_history[1], &_iconsole_history[0], sizeof(_iconsole_history[0]) * (ICON_HISTORY_SIZE - 1));
 471                 _iconsole_history[0] = stredup(cmd);
 472         }
 473
 474         /* Reset the history position */
 475         IConsoleResetHistoryPos();
 476         return _iconsole_history[0];
 477 }
 478
 479 /**
 480  * Navigate Up/Down in the history of typed commands
 481  * @param direction Go further back in history (+1), go to recently typed commands (-1)
 482  */
 483 static void IConsoleHistoryNavigate(int direction)
 484 {
 485         if (_iconsole_history[0] == nullptr) return; // Empty history
 486         _iconsole_historypos = Clamp(_iconsole_historypos + direction, -1, ICON_HISTORY_SIZE - 1);
 487
 488         if (direction > 0 && _iconsole_history[_iconsole_historypos] == nullptr) _iconsole_historypos--;
 489
 490         if (_iconsole_historypos == -1) {
 491                 _iconsole_cmdline.DeleteAll();
 492         } else {
 493                 _iconsole_cmdline.Assign(_iconsole_history[_iconsole_historypos]);
 494         }
 495 }
 496
 497 /**
 498  * Handle the printing of text entered into the console or redirected there
 499  * by any other means. Text can be redirected to other clients in a network game
 500  * as well as to a logfile. If the network server is a dedicated server, all activities
 501  * are also logged. All lines to print are added to a temporary buffer which can be
 502  * used as a history to print them onscreen
 503  * @param colour_code the colour of the command. Red in case of errors, etc.
 504  * @param str the message entered or output on the console (notice, error, etc.)
 505  */
 506 void IConsoleGUIPrint(TextColour colour_code, char *str)
 507 {
 508         new IConsoleLine(str, colour_code);
 509         SetWindowDirty(WC_CONSOLE, 0);
 510 }
 511
 512
 513 /**
 514  * Check whether the given TextColour is valid for console usage.
 515  * @param c The text colour to compare to.
 516  * @return true iff the TextColour is valid for console usage.
 517  */
 518 bool IsValidConsoleColour(TextColour c)
 519 {
 520         /* A normal text colour is used. */
 521         if (!(c & TC_IS_PALETTE_COLOUR)) return TC_BEGIN <= c && c < TC_END;
 522
 523         /* A text colour from the palette is used; must be the company
 524          * colour gradient, so it must be one of those. */
 525         c &= ~TC_IS_PALETTE_COLOUR;
 526         for (uint i = COLOUR_BEGIN; i < COLOUR_END; i++) {
 527                 if (_colour_gradient[i][4] == c) return true;
 528         }
 529
 530         return false;
 531 }