1 /* $Id$ */

     2 

     3 /** @file console.cpp Handling of the in-game console. */

     4 

     5 #include "stdafx.h"

     6 #include "openttd.h"

     7 #include "textbuf_gui.h"

     8 #include "window_gui.h"

     9 #include "console_gui.h"

    10 #include <stdarg.h>

    11 #include <string.h>

    12 #include "console_internal.h"

    13 #include "window_func.h"

    14 #include "string_func.h"

    15 #include "gfx_func.h"

    16 #include "core/math_func.hpp"

    17 #include "rev.h"

    18 

    19 #include "table/strings.h"

    20 

    21 #define ICON_BUFFER 79

    22 #define ICON_HISTORY_SIZE 20

    23 #define ICON_LINE_HEIGHT 12

    24 #define ICON_RIGHT_BORDERWIDTH 10

    25 #define ICON_BOTTOM_BORDERWIDTH 12

    26 #define ICON_MAX_ALIAS_LINES 40

    27 #define ICON_TOKEN_COUNT 20

    28 

    29 /* console modes */

    30 IConsoleModes _iconsole_mode;

    31 

    32 /* ** main console ** */

    33 static char *_iconsole_buffer[ICON_BUFFER + 1];

    34 static uint16 _iconsole_cbuffer[ICON_BUFFER + 1];

    35 static Textbuf _iconsole_cmdline;

    36 

    37 /* ** main console cmd buffer ** */

    38 static char *_iconsole_history[ICON_HISTORY_SIZE];

    39 static byte _iconsole_historypos;

    40 

    41 /* *************** *

    42  *  end of header  *

    43  * *************** */

    44 

    45 static void IConsoleClearCommand()

    46 {

    47 	memset(_iconsole_cmdline.buf, 0, ICON_CMDLN_SIZE);

    48 	_iconsole_cmdline.length = 0;

    49 	_iconsole_cmdline.width = 0;

    50 	_iconsole_cmdline.caretpos = 0;

    51 	_iconsole_cmdline.caretxoffs = 0;

    52 	SetWindowDirty(FindWindowById(WC_CONSOLE, 0));

    53 }

    54 

    55 static inline void IConsoleResetHistoryPos() {_iconsole_historypos = ICON_HISTORY_SIZE - 1;}

    56 

    57 

    58 static void IConsoleHistoryAdd(const char *cmd);

    59 static void IConsoleHistoryNavigate(int direction);

    60 

    61 struct IConsoleWindow : Window

    62 {

    63 	static byte scroll;

    64 

    65 	IConsoleWindow(const WindowDesc *desc) : Window(desc)

    66 	{

    67 		_iconsole_mode = ICONSOLE_OPENED;

    68 		SetBit(_no_scroll, SCROLL_CON); // override cursor arrows; the gamefield will not scroll

    69 

    70 		this->height = _screen.height / 3;

    71 		this->width  = _screen.width;

    72 	}

    73 

    74 	~IConsoleWindow()

    75 	{

    76 		_iconsole_mode = ICONSOLE_CLOSED;

    77 		ClrBit(_no_scroll, SCROLL_CON);

    78 	}

    79 

    80 	virtual void OnPaint()

    81 	{

    82 		int i = IConsoleWindow::scroll;

    83 		int max = (this->height / ICON_LINE_HEIGHT) - 1;

    84 		int delta = 0;

    85 		GfxFillRect(this->left, this->top, this->width, this->height - 1, 0);

    86 		while ((i > 0) && (i > IConsoleWindow::scroll - max) && (_iconsole_buffer[i] != NULL)) {

    87 			DoDrawString(_iconsole_buffer[i], 5,

    88 				this->height - (IConsoleWindow::scroll + 2 - i) * ICON_LINE_HEIGHT, _iconsole_cbuffer[i]);

    89 			i--;

    90 		}

    91 		/* If the text is longer than the window, don't show the starting ']' */

    92 		delta = this->width - 10 - _iconsole_cmdline.width - ICON_RIGHT_BORDERWIDTH;

    93 		if (delta > 0) {

    94 			DoDrawString("]", 5, this->height - ICON_LINE_HEIGHT, CC_COMMAND);

    95 			delta = 0;

    96 		}

    97 

    98 		DoDrawString(_iconsole_cmdline.buf, 10 + delta, this->height - ICON_LINE_HEIGHT, CC_COMMAND);

    99 

   100 		if (_iconsole_cmdline.caret) {

   101 			DoDrawString("_", 10 + delta + _iconsole_cmdline.caretxoffs, this->height - ICON_LINE_HEIGHT, TC_WHITE);

   102 		}

   103 	}

   104 

   105 	virtual void OnMouseLoop()

   106 	{

   107 		if (HandleCaret(&_iconsole_cmdline)) this->SetDirty();

   108 	}

   109 

   110 	virtual EventState OnKeyPress(uint16 key, uint16 keycode)

   111 	{

   112 		switch (keycode) {

   113 			case WKC_UP:

   114 				IConsoleHistoryNavigate(+1);

   115 				this->SetDirty();

   116 				break;

   117 

   118 			case WKC_DOWN:

   119 				IConsoleHistoryNavigate(-1);

   120 				this->SetDirty();

   121 				break;

   122 

   123 			case WKC_SHIFT | WKC_PAGEUP:

   124 				if (IConsoleWindow::scroll - (this->height / ICON_LINE_HEIGHT) - 1 < 0) {

   125 					IConsoleWindow::scroll = 0;

   126 				} else {

   127 					IConsoleWindow::scroll -= (this->height / ICON_LINE_HEIGHT) - 1;

   128 				}

   129 				this->SetDirty();

   130 				break;

   131 

   132 			case WKC_SHIFT | WKC_PAGEDOWN:

   133 				if (IConsoleWindow::scroll + (this->height / ICON_LINE_HEIGHT) - 1 > ICON_BUFFER) {

   134 					IConsoleWindow::scroll = ICON_BUFFER;

   135 				} else {

   136 					IConsoleWindow::scroll += (this->height / ICON_LINE_HEIGHT) - 1;

   137 				}

   138 				this->SetDirty();

   139 				break;

   140 

   141 			case WKC_SHIFT | WKC_UP:

   142 				if (IConsoleWindow::scroll <= 0) {

   143 					IConsoleWindow::scroll = 0;

   144 				} else {

   145 					--IConsoleWindow::scroll;

   146 				}

   147 				this->SetDirty();

   148 				break;

   149 

   150 			case WKC_SHIFT | WKC_DOWN:

   151 				if (IConsoleWindow::scroll >= ICON_BUFFER) {

   152 					IConsoleWindow::scroll = ICON_BUFFER;

   153 				} else {

   154 					++IConsoleWindow::scroll;

   155 				}

   156 				this->SetDirty();

   157 				break;

   158 

   159 			case WKC_BACKQUOTE:

   160 				IConsoleSwitch();

   161 				break;

   162 

   163 			case WKC_RETURN: case WKC_NUM_ENTER:

   164 				IConsolePrintF(CC_COMMAND, "] %s", _iconsole_cmdline.buf);

   165 				IConsoleHistoryAdd(_iconsole_cmdline.buf);

   166 

   167 				IConsoleCmdExec(_iconsole_cmdline.buf);

   168 				IConsoleClearCommand();

   169 				break;

   170 

   171 			case WKC_CTRL | WKC_RETURN:

   172 				_iconsole_mode = (_iconsole_mode == ICONSOLE_FULL) ? ICONSOLE_OPENED : ICONSOLE_FULL;

   173 				IConsoleResize(this);

   174 				MarkWholeScreenDirty();

   175 				break;

   176 

   177 			case (WKC_CTRL | 'V'):

   178 				if (InsertTextBufferClipboard(&_iconsole_cmdline)) {

   179 					IConsoleResetHistoryPos();

   180 					this->SetDirty();

   181 				}

   182 				break;

   183 

   184 			case (WKC_CTRL | 'L'):

   185 				IConsoleCmdExec("clear");

   186 				break;

   187 

   188 			case (WKC_CTRL | 'U'):

   189 				DeleteTextBufferAll(&_iconsole_cmdline);

   190 				this->SetDirty();

   191 				break;

   192 

   193 			case WKC_BACKSPACE: case WKC_DELETE:

   194 				if (DeleteTextBufferChar(&_iconsole_cmdline, keycode)) {

   195 					IConsoleResetHistoryPos();

   196 					this->SetDirty();

   197 				}

   198 				break;

   199 

   200 			case WKC_LEFT: case WKC_RIGHT: case WKC_END: case WKC_HOME:

   201 				if (MoveTextBufferPos(&_iconsole_cmdline, keycode)) {

   202 					IConsoleResetHistoryPos();

   203 					this->SetDirty();

   204 				}

   205 				break;

   206 

   207 			default:

   208 				if (IsValidChar(key, CS_ALPHANUMERAL)) {

   209 					IConsoleWindow::scroll = ICON_BUFFER;

   210 					InsertTextBufferChar(&_iconsole_cmdline, key);

   211 					IConsoleResetHistoryPos();

   212 					this->SetDirty();

   213 				} else {

   214 					return ES_NOT_HANDLED;

   215 				}

   216 		}

   217 		return ES_HANDLED;

   218 	}

   219 };

   220 

   221 byte IConsoleWindow::scroll = ICON_BUFFER;

   222 

   223 static const Widget _iconsole_window_widgets[] = {

   224 	{WIDGETS_END}

   225 };

   226 

   227 static const WindowDesc _iconsole_window_desc = {

   228 	0, 0, 2, 2, 2, 2,

   229 	WC_CONSOLE, WC_NONE,

   230 	WDF_STD_TOOLTIPS | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS,

   231 	_iconsole_window_widgets,

   232 };

   233 

   234 void IConsoleGUIInit()

   235 {

   236 	_iconsole_historypos = ICON_HISTORY_SIZE - 1;

   237 	_iconsole_mode = ICONSOLE_CLOSED;

   238 

   239 	memset(_iconsole_history, 0, sizeof(_iconsole_history));

   240 	memset(_iconsole_buffer, 0, sizeof(_iconsole_buffer));

   241 	memset(_iconsole_cbuffer, 0, sizeof(_iconsole_cbuffer));

   242 	_iconsole_cmdline.buf = CallocT<char>(ICON_CMDLN_SIZE); // create buffer and zero it

   243 	_iconsole_cmdline.maxlength = ICON_CMDLN_SIZE;

   244 

   245 	IConsolePrintF(CC_WARNING, "OpenTTD Game Console Revision 7 - %s", _openttd_revision);

   246 	IConsolePrint(CC_WHITE,  "------------------------------------");

   247 	IConsolePrint(CC_WHITE,  "use \"help\" for more information");

   248 	IConsolePrint(CC_WHITE,  "");

   249 	IConsoleClearCommand();

   250 	IConsoleHistoryAdd("");

   251 }

   252 

   253 void IConsoleClearBuffer()

   254 {

   255 	uint i;

   256 	for (i = 0; i <= ICON_BUFFER; i++) {

   257 		free(_iconsole_buffer[i]);

   258 		_iconsole_buffer[i] = NULL;

   259 	}

   260 }

   261 

   262 void IConsoleGUIFree()

   263 {

   264 	free(_iconsole_cmdline.buf);

   265 	IConsoleClearBuffer();

   266 }

   267 

   268 void IConsoleResize(Window *w)

   269 {

   270 	switch (_iconsole_mode) {

   271 		case ICONSOLE_OPENED:

   272 			w->height = _screen.height / 3;

   273 			w->width = _screen.width;

   274 			break;

   275 		case ICONSOLE_FULL:

   276 			w->height = _screen.height - ICON_BOTTOM_BORDERWIDTH;

   277 			w->width = _screen.width;

   278 			break;

   279 		default: return;

   280 	}

   281 

   282 	MarkWholeScreenDirty();

   283 }

   284 

   285 void IConsoleSwitch()

   286 {

   287 	switch (_iconsole_mode) {

   288 		case ICONSOLE_CLOSED:

   289 			new IConsoleWindow(&_iconsole_window_desc);

   290 			break;

   291 

   292 		case ICONSOLE_OPENED: case ICONSOLE_FULL:

   293 			DeleteWindowById(WC_CONSOLE, 0);

   294 			break;

   295 	}

   296 

   297 	MarkWholeScreenDirty();

   298 }

   299 

   300 void IConsoleClose() {if (_iconsole_mode == ICONSOLE_OPENED) IConsoleSwitch();}

   301 void IConsoleOpen()  {if (_iconsole_mode == ICONSOLE_CLOSED) IConsoleSwitch();}

   302 

   303 /**

   304  * Add the entered line into the history so you can look it back

   305  * scroll, etc. Put it to the beginning as it is the latest text

   306  * @param cmd Text to be entered into the 'history'

   307  */

   308 static void IConsoleHistoryAdd(const char *cmd)

   309 {

   310 	free(_iconsole_history[ICON_HISTORY_SIZE - 1]);

   311 

   312 	memmove(&_iconsole_history[1], &_iconsole_history[0], sizeof(_iconsole_history[0]) * (ICON_HISTORY_SIZE - 1));

   313 	_iconsole_history[0] = strdup(cmd);

   314 	IConsoleResetHistoryPos();

   315 }

   316 

   317 /**

   318  * Navigate Up/Down in the history of typed commands

   319  * @param direction Go further back in history (+1), go to recently typed commands (-1)

   320  */

   321 static void IConsoleHistoryNavigate(int direction)

   322 {

   323 	int i = _iconsole_historypos + direction;

   324 

   325 	/* watch out for overflows, just wrap around */

   326 	if (i < 0) i = ICON_HISTORY_SIZE - 1;

   327 	if (i >= ICON_HISTORY_SIZE) i = 0;

   328 

   329 	if (direction > 0) {

   330 		if (_iconsole_history[i] == NULL) i = 0;

   331 	}

   332 

   333 	if (direction < 0) {

   334 		while (i > 0 && _iconsole_history[i] == NULL) i--;

   335 	}

   336 

   337 	_iconsole_historypos = i;

   338 	IConsoleClearCommand();

   339 	/* copy history to 'command prompt / bash' */

   340 	assert(_iconsole_history[i] != NULL && IsInsideMM(i, 0, ICON_HISTORY_SIZE));

   341 	ttd_strlcpy(_iconsole_cmdline.buf, _iconsole_history[i], _iconsole_cmdline.maxlength);

   342 	UpdateTextBufferSize(&_iconsole_cmdline);

   343 }

   344 

   345 /**

   346  * Handle the printing of text entered into the console or redirected there

   347  * by any other means. Text can be redirected to other players in a network game

   348  * as well as to a logfile. If the network server is a dedicated server, all activities

   349  * are also logged. All lines to print are added to a temporary buffer which can be

   350  * used as a history to print them onscreen

   351  * @param color_code the colour of the command. Red in case of errors, etc.

   352  * @param string the message entered or output on the console (notice, error, etc.)

   353  */

   354 void IConsoleGUIPrint(ConsoleColour color_code, char *str)

   355 {

   356 	/* move up all the strings in the buffer one place and do the same for colour

   357 	 * to accomodate for the new command/message */

   358 	free(_iconsole_buffer[0]);

   359 	memmove(&_iconsole_buffer[0], &_iconsole_buffer[1], sizeof(_iconsole_buffer[0]) * ICON_BUFFER);

   360 	_iconsole_buffer[ICON_BUFFER] = str;

   361 

   362 	memmove(&_iconsole_cbuffer[0], &_iconsole_cbuffer[1], sizeof(_iconsole_cbuffer[0]) * ICON_BUFFER);

   363 	_iconsole_cbuffer[ICON_BUFFER] = color_code;

   364 

   365 	SetWindowDirty(FindWindowById(WC_CONSOLE, 0));

   366 }