1

/* $Id$ */

     2

     3

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

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "gui.h"

     8

#include "textbuf_gui.h"

     9

#include "window_gui.h"

    10

#include "variables.h"

    11

#include <stdarg.h>

    12

#include <string.h>

    13

#include "console.h"

    14

#include "network/network.h"

    15

#include "network/network_data.h"

    16

#include "network/network_server.h"

    17

#include "core/alloc_func.hpp"

    18

#include "window_func.h"

    19

#include "string_func.h"

    20

#include "gfx_func.h"

    21

#include "rev.h"

    22

    23

#include "table/strings.h"

    24

    25

#define ICON_BUFFER 79

    26

#define ICON_HISTORY_SIZE 20

    27

#define ICON_LINE_HEIGHT 12

    28

#define ICON_RIGHT_BORDERWIDTH 10

    29

#define ICON_BOTTOM_BORDERWIDTH 12

    30

#define ICON_MAX_ALIAS_LINES 40

    31

#define ICON_TOKEN_COUNT 20

    32

    33

/* console parser */

    34

IConsoleCmd   *_iconsole_cmds;    ///< list of registred commands

    35

IConsoleVar   *_iconsole_vars;    ///< list of registred vars

    36

IConsoleAlias *_iconsole_aliases; ///< list of registred aliases

    37

    38

/* console colors/modes */

    39

byte _icolour_def;

    40

byte _icolour_err;

    41

byte _icolour_warn;

    42

byte _icolour_dbg;

    43

byte _icolour_cmd;

    44

IConsoleModes _iconsole_mode;

    45

    46

/* ** main console ** */

    47

static char *_iconsole_buffer[ICON_BUFFER + 1];

    48

static uint16 _iconsole_cbuffer[ICON_BUFFER + 1];

    49

static Textbuf _iconsole_cmdline;

    50

    51

/* ** stdlib ** */

    52

byte _stdlib_developer = 1;

    53

bool _stdlib_con_developer = false;

    54

FILE *_iconsole_output_file;

    55

    56

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

    57

static char *_iconsole_history[ICON_HISTORY_SIZE];

    58

static byte _iconsole_historypos;

    59

    60

/* *************** *

    61

 *  end of header  *

    62

 * *************** */

    63

    64

static void IConsoleClearCommand()

    65

{

    66

	memset(_iconsole_cmdline.buf, 0, ICON_CMDLN_SIZE);

    67

	_iconsole_cmdline.length = 0;

    68

	_iconsole_cmdline.width = 0;

    69

	_iconsole_cmdline.caretpos = 0;

    70

	_iconsole_cmdline.caretxoffs = 0;

    71

	SetWindowDirty(FindWindowById(WC_CONSOLE, 0));

    72

}

    73

    74

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

    75

    76

    77

static void IConsoleHistoryAdd(const char *cmd);

    78

static void IConsoleHistoryNavigate(int direction);

    79

    80

/* ** console window ** */

    81

static void IConsoleWndProc(Window *w, WindowEvent *e)

    82

{

    83

	static byte iconsole_scroll = ICON_BUFFER;

    84

    85

	switch (e->event) {

    86

		case WE_PAINT: {

    87

			int i = iconsole_scroll;

    88

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

    89

			int delta = 0;

    90

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

    91

			while ((i > 0) && (i > iconsole_scroll - max) && (_iconsole_buffer[i] != NULL)) {

    92

				DoDrawString(_iconsole_buffer[i], 5,

    93

					w->height - (iconsole_scroll + 2 - i) * ICON_LINE_HEIGHT, _iconsole_cbuffer[i]);

    94

				i--;

    95

			}

    96

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

    97

			delta = w->width - 10 - _iconsole_cmdline.width - ICON_RIGHT_BORDERWIDTH;

    98

			if (delta > 0) {

    99

				DoDrawString("]", 5, w->height - ICON_LINE_HEIGHT, _icolour_cmd);

   100

				delta = 0;

   101

			}

   102

   103

			DoDrawString(_iconsole_cmdline.buf, 10 + delta, w->height - ICON_LINE_HEIGHT, _icolour_cmd);

   104

   105

			if (_iconsole_cmdline.caret)

   106

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

   107

			break;

   108

		}

   109

		case WE_MOUSELOOP:

   110

			if (HandleCaret(&_iconsole_cmdline)) w->SetDirty();

   111

			break;

   112

		case WE_DESTROY:

   113

			_iconsole_mode = ICONSOLE_CLOSED;

   114

			break;

   115

		case WE_KEYPRESS:

   116

			e->we.keypress.cont = false;

   117

			switch (e->we.keypress.keycode) {

   118

				case WKC_UP:

   119

					IConsoleHistoryNavigate(+1);

   120

					w->SetDirty();

   121

					break;

   122

				case WKC_DOWN:

   123

					IConsoleHistoryNavigate(-1);

   124

					w->SetDirty();

   125

					break;

   126

				case WKC_SHIFT | WKC_PAGEUP:

   127

					if (iconsole_scroll - (w->height / ICON_LINE_HEIGHT) - 1 < 0) {

   128

						iconsole_scroll = 0;

   129

					} else {

   130

						iconsole_scroll -= (w->height / ICON_LINE_HEIGHT) - 1;

   131

					}

   132

					w->SetDirty();

   133

					break;

   134

				case WKC_SHIFT | WKC_PAGEDOWN:

   135

					if (iconsole_scroll + (w->height / ICON_LINE_HEIGHT) - 1 > ICON_BUFFER) {

   136

						iconsole_scroll = ICON_BUFFER;

   137

					} else {

   138

						iconsole_scroll += (w->height / ICON_LINE_HEIGHT) - 1;

   139

					}

   140

					w->SetDirty();

   141

					break;

   142

				case WKC_SHIFT | WKC_UP:

   143

					if (iconsole_scroll <= 0) {

   144

						iconsole_scroll = 0;

   145

					} else {

   146

						--iconsole_scroll;

   147

					}

   148

					w->SetDirty();

   149

					break;

   150

				case WKC_SHIFT | WKC_DOWN:

   151

					if (iconsole_scroll >= ICON_BUFFER) {

   152

						iconsole_scroll = ICON_BUFFER;

   153

					} else {

   154

						++iconsole_scroll;

   155

					}

   156

					w->SetDirty();

   157

					break;

   158

				case WKC_BACKQUOTE:

   159

					IConsoleSwitch();

   160

					break;

   161

				case WKC_RETURN: case WKC_NUM_ENTER:

   162

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

   163

					IConsoleHistoryAdd(_iconsole_cmdline.buf);

   164

   165

					IConsoleCmdExec(_iconsole_cmdline.buf);

   166

					IConsoleClearCommand();

   167

					break;

   168

				case WKC_CTRL | WKC_RETURN:

   169

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

   170

					IConsoleResize(w);

   171

					MarkWholeScreenDirty();

   172

					break;

   173

				case (WKC_CTRL | 'V'):

   174

					if (InsertTextBufferClipboard(&_iconsole_cmdline)) {

   175

						IConsoleResetHistoryPos();

   176

						w->SetDirty();

   177

					}

   178

					break;

   179

				case (WKC_CTRL | 'L'):

   180

					IConsoleCmdExec("clear");

   181

					break;

   182

				case (WKC_CTRL | 'U'):

   183

					DeleteTextBufferAll(&_iconsole_cmdline);

   184

					w->SetDirty();

   185

					break;

   186

				case WKC_BACKSPACE: case WKC_DELETE:

   187

					if (DeleteTextBufferChar(&_iconsole_cmdline, e->we.keypress.keycode)) {

   188

						IConsoleResetHistoryPos();

   189

						w->SetDirty();

   190

					}

   191

					break;

   192

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

   193

					if (MoveTextBufferPos(&_iconsole_cmdline, e->we.keypress.keycode)) {

   194

						IConsoleResetHistoryPos();

   195

						w->SetDirty();

   196

					}

   197

					break;

   198

				default:

   199

					if (IsValidChar(e->we.keypress.key, CS_ALPHANUMERAL)) {

   200

						iconsole_scroll = ICON_BUFFER;

   201

						InsertTextBufferChar(&_iconsole_cmdline, e->we.keypress.key);

   202

						IConsoleResetHistoryPos();

   203

						w->SetDirty();

   204

					} else {

   205

						e->we.keypress.cont = true;

   206

					}

   207

			break;

   208

		}

   209

	}

   210

}

   211

   212

static const Widget _iconsole_window_widgets[] = {

   213

	{WIDGETS_END}

   214

};

   215

   216

static const WindowDesc _iconsole_window_desc = {

   217

	0, 0, 2, 2, 2, 2,

   218

	WC_CONSOLE, WC_NONE,

   219

	WDF_STD_TOOLTIPS | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS,

   220

	_iconsole_window_widgets,

   221

	IConsoleWndProc,

   222

};

   223

   224

void IConsoleInit()

   225

{

   226

	_iconsole_output_file = NULL;

   227

	_icolour_def  =  1;

   228

	_icolour_err  =  3;

   229

	_icolour_warn = 13;

   230

	_icolour_dbg  =  5;

   231

	_icolour_cmd  = TC_GOLD;

   232

	_iconsole_historypos = ICON_HISTORY_SIZE - 1;

   233

	_iconsole_mode = ICONSOLE_CLOSED;

   234

   235

#ifdef ENABLE_NETWORK /* Initialize network only variables */

   236

	_redirect_console_to_client = 0;

   237

#endif

   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(13, "OpenTTD Game Console Revision 7 - %s", _openttd_revision);

   246

	IConsolePrint(12,  "------------------------------------");

   247

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

   248

	IConsolePrint(12,  "");

   249

	IConsoleStdLibRegister();

   250

	IConsoleClearCommand();

   251

	IConsoleHistoryAdd("");

   252

}

   253

   254

void IConsoleClearBuffer()

   255

{

   256

	uint i;

   257

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

   258

		free(_iconsole_buffer[i]);

   259

		_iconsole_buffer[i] = NULL;

   260

	}

   261

}

   262

   263

static void IConsoleClear()

   264

{

   265

	free(_iconsole_cmdline.buf);

   266

	IConsoleClearBuffer();

   267

}

   268

   269

static void IConsoleWriteToLogFile(const char *string)

   270

{

   271

	if (_iconsole_output_file != NULL) {

   272

		/* if there is an console output file ... also print it there */

   273

		if (fwrite(string, strlen(string), 1, _iconsole_output_file) != 1 ||

   274

				fwrite("\n", 1, 1, _iconsole_output_file) != 1) {

   275

			fclose(_iconsole_output_file);

   276

			_iconsole_output_file = NULL;

   277

			IConsolePrintF(_icolour_def, "cannot write to log file");

   278

		}

   279

	}

   280

}

   281

   282

bool CloseConsoleLogIfActive()

   283

{

   284

	if (_iconsole_output_file != NULL) {

   285

		IConsolePrintF(_icolour_def, "file output complete");

   286

		fclose(_iconsole_output_file);

   287

		_iconsole_output_file = NULL;

   288

		return true;

   289

	}

   290

   291

	return false;

   292

}

   293

   294

void IConsoleFree()

   295

{

   296

	IConsoleClear();

   297

	CloseConsoleLogIfActive();

   298

}

   299

   300

void IConsoleResize(Window *w)

   301

{

   302

	switch (_iconsole_mode) {

   303

		case ICONSOLE_OPENED:

   304

			w->height = _screen.height / 3;

   305

			w->width = _screen.width;

   306

			break;

   307

		case ICONSOLE_FULL:

   308

			w->height = _screen.height - ICON_BOTTOM_BORDERWIDTH;

   309

			w->width = _screen.width;

   310

			break;

   311

		default: return;

   312

	}

   313

   314

	MarkWholeScreenDirty();

   315

}

   316

   317

void IConsoleSwitch()

   318

{

   319

	switch (_iconsole_mode) {

   320

		case ICONSOLE_CLOSED: {

   321

			Window *w = AllocateWindowDesc(&_iconsole_window_desc);

   322

			w->height = _screen.height / 3;

   323

			w->width = _screen.width;

   324

			_iconsole_mode = ICONSOLE_OPENED;

   325

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

   326

		} break;

   327

		case ICONSOLE_OPENED: case ICONSOLE_FULL:

   328

			DeleteWindowById(WC_CONSOLE, 0);

   329

			_iconsole_mode = ICONSOLE_CLOSED;

   330

			ClrBit(_no_scroll, SCROLL_CON);

   331

			break;

   332

	}

   333

   334

	MarkWholeScreenDirty();

   335

}

   336

   337

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

   338

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

   339

   340

/**

   341

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

   342

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

   343

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

   344

 */

   345

static void IConsoleHistoryAdd(const char *cmd)

   346

{

   347

	free(_iconsole_history[ICON_HISTORY_SIZE - 1]);

   348

   349

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

   350

	_iconsole_history[0] = strdup(cmd);

   351

	IConsoleResetHistoryPos();

   352

}

   353

   354

/**

   355

 * Navigate Up/Down in the history of typed commands

   356

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

   357

 */

   358

static void IConsoleHistoryNavigate(int direction)

   359

{

   360

	int i = _iconsole_historypos + direction;

   361

   362

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

   363

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

   364

	if (i >= ICON_HISTORY_SIZE) i = 0;

   365

   366

	if (direction > 0)

   367

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

   368

   369

	if (direction < 0) {

   370

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

   371

	}

   372

   373

	_iconsole_historypos = i;

   374

	IConsoleClearCommand();

   375

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

   376

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

   377

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

   378

	UpdateTextBufferSize(&_iconsole_cmdline);

   379

}

   380

   381

/**

   382

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

   383

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

   384

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

   385

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

   386

 * used as a history to print them onscreen

   387

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

   388

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

   389

 */

   390

void IConsolePrint(uint16 color_code, const char *string)

   391

{

   392

	char *str;

   393

#ifdef ENABLE_NETWORK

   394

	if (_redirect_console_to_client != 0) {

   395

		/* Redirect the string to the client */

   396

		SEND_COMMAND(PACKET_SERVER_RCON)(NetworkFindClientStateFromIndex(_redirect_console_to_client), color_code, string);

   397

		return;

   398

	}

   399

#endif

   400

   401

	/* Create a copy of the string, strip if of colours and invalid

   402

	 * characters and (when applicable) assign it to the console buffer */

   403

	str = strdup(string);

   404

	str_strip_colours(str);

   405

	str_validate(str);

   406

   407

	if (_network_dedicated) {

   408

		fprintf(stdout, "%s\n", str);

   409

		fflush(stdout);

   410

		IConsoleWriteToLogFile(str);

   411

		free(str); // free duplicated string since it's not used anymore

   412

		return;

   413

	}

   414

   415

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

   416

	 * to accomodate for the new command/message */

   417

	free(_iconsole_buffer[0]);

   418

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

   419

	_iconsole_buffer[ICON_BUFFER] = str;

   420

   421

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

   422

	_iconsole_cbuffer[ICON_BUFFER] = color_code;

   423

   424

	IConsoleWriteToLogFile(_iconsole_buffer[ICON_BUFFER]);

   425

   426

	SetWindowDirty(FindWindowById(WC_CONSOLE, 0));

   427

}

   428

   429

/**

   430

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

   431

 * by any other means. Uses printf() style format, for more information look

   432

 * at IConsolePrint()

   433

 */

   434

void CDECL IConsolePrintF(uint16 color_code, const char *s, ...)

   435

{

   436

	va_list va;

   437

	char buf[ICON_MAX_STREAMSIZE];

   438

   439

	va_start(va, s);

   440

	vsnprintf(buf, sizeof(buf), s, va);

   441

	va_end(va);

   442

   443

	IConsolePrint(color_code, buf);

   444

}

   445

   446

/**

   447

 * It is possible to print debugging information to the console,

   448

 * which is achieved by using this function. Can only be used by

   449

 * debug() in debug.cpp. You need at least a level 2 (developer) for debugging

   450

 * messages to show up

   451

 * @param dbg debugging category

   452

 * @param string debugging message

   453

 */

   454

void IConsoleDebug(const char *dbg, const char *string)

   455

{

   456

	if (_stdlib_developer > 1)

   457

		IConsolePrintF(_icolour_dbg, "dbg: [%s] %s", dbg, string);

   458

}

   459

   460

/**

   461

 * It is possible to print warnings to the console. These are mostly

   462

 * errors or mishaps, but non-fatal. You need at least a level 1 (developer) for

   463

 * debugging messages to show up

   464

 */

   465

void IConsoleWarning(const char *string)

   466

{

   467

	if (_stdlib_developer > 0)

   468

		IConsolePrintF(_icolour_warn, "WARNING: %s", string);

   469

}

   470

   471

/**

   472

 * It is possible to print error information to the console. This can include

   473

 * game errors, or errors in general you would want the user to notice

   474

 */

   475

void IConsoleError(const char *string)

   476

{

   477

	IConsolePrintF(_icolour_err, "ERROR: %s", string);

   478