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