1

/* $Id$ */

     2

     3

/** @file console_gui.cpp Handling the GUI 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 "settings_type.h"

    18

#include "rev.h"

    19

    20

#include "table/strings.h"

    21

    22

enum {

    23

	ICON_HISTORY_SIZE       = 20,

    24

	ICON_LINE_HEIGHT        = 12,

    25

	ICON_RIGHT_BORDERWIDTH  = 10,

    26

	ICON_BOTTOM_BORDERWIDTH = 12,

    27

};

    28

    29

/**

    30

 * Container for a single line of console output

    31

 */

    32

struct IConsoleLine {

    33

	static IConsoleLine *front; ///< The front of the console backlog buffer

    34

	static int size;            ///< The amount of items in the backlog

    35

    36

	IConsoleLine *previous; ///< The previous console message.

    37

	char *buffer;          ///< The data to store.

    38

	uint16 colour;         ///< The colour of the line.

    39

	uint16 time;           ///< The amount of time the line is in the backlog.

    40

    41

	/**

    42

	 * Initialize the console line.

    43

	 * @param buffer the data to print.

    44

	 * @param colour the colour of the line.

    45

	 */

    46

	IConsoleLine(char *buffer, uint16 colour) :

    47

			previous(IConsoleLine::front),

    48

			buffer(buffer),

    49

			colour(colour),

    50

			time(0)

    51

	{

    52

		IConsoleLine::front = this;

    53

		IConsoleLine::size++;

    54

	}

    55

    56

	/**

    57

	 * Clear this console line and any further ones.

    58

	 */

    59

	~IConsoleLine()

    60

	{

    61

		IConsoleLine::size--;

    62

		free(buffer);

    63

    64

		delete previous;

    65

	}

    66

    67

	/**

    68

	 * Get the index-ed item in the list.

    69

	 */

    70

	static const IConsoleLine *Get(uint index)

    71

	{

    72

		const IConsoleLine *item = IConsoleLine::front;

    73

		while (index != 0 && item != NULL) {

    74

			index--;

    75

			item = item->previous;

    76

		}

    77

    78

		return item;

    79

	}

    80

    81

	/**

    82

	 * Truncate the list removing everything older than/more than the amount

    83

	 * as specified in the config file.

    84

	 * As a side effect also increase the time the other lines have been in

    85

	 * the list.

    86

	 * @return true if and only if items got removed.

    87

	 */

    88

	static bool Truncate()

    89

	{

    90

		IConsoleLine *cur = IConsoleLine::front;

    91

		if (cur == NULL) return false;

    92

    93

		int count = 1;

    94

		for (IConsoleLine *item = cur->previous; item != NULL; count++, cur = item, item = item->previous) {

    95

			if (item->time > _settings_client.gui.console_backlog_timeout &&

    96

					count > _settings_client.gui.console_backlog_length) {

    97

				delete item;

    98

				cur->previous = NULL;

    99

				return true;

   100

			}

   101

   102

			if (item->time != MAX_UVALUE(uint16)) item->time++;

   103

		}

   104

   105

		return false;

   106

	}

   107

   108

	/**

   109

	 * Reset the complete console line backlog.

   110

	 */

   111

	static void Reset()

   112

	{

   113

		delete IConsoleLine::front;

   114

		IConsoleLine::front = NULL;

   115

		IConsoleLine::size = 0;

   116

	}

   117

};

   118

   119

/* static */ IConsoleLine *IConsoleLine::front = NULL;

   120

/* static */ int IConsoleLine::size  = 0;

   121

   122

   123

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

   124

static Textbuf _iconsole_cmdline;

   125

static char *_iconsole_history[ICON_HISTORY_SIZE];

   126

static byte _iconsole_historypos;

   127

IConsoleModes _iconsole_mode;

   128

   129

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

   130

 *  end of header  *

   131

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

   132

   133

static void IConsoleClearCommand()

   134

{

   135

	memset(_iconsole_cmdline.buf, 0, ICON_CMDLN_SIZE);

   136

	_iconsole_cmdline.size = 1; // only terminating zero

   137

	_iconsole_cmdline.width = 0;

   138

	_iconsole_cmdline.caretpos = 0;

   139

	_iconsole_cmdline.caretxoffs = 0;

   140

	SetWindowDirty(FindWindowById(WC_CONSOLE, 0));

   141

}

   142

   143

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

   144

   145

   146

static void IConsoleHistoryAdd(const char *cmd);

   147

static void IConsoleHistoryNavigate(int direction);

   148

   149

struct IConsoleWindow : Window

   150

{

   151

	static int scroll;

   152

   153

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

   154

	{

   155

		_iconsole_mode = ICONSOLE_OPENED;

   157

   158

		this->height = _screen.height / 3;

   159

		this->width  = _screen.width;

   160

	}

   161

   162

	~IConsoleWindow()

   163

	{

   164

		_iconsole_mode = ICONSOLE_CLOSED;

   166

	}

   167

   168

	virtual void OnPaint()

   169

	{

   170

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

   171

		const IConsoleLine *print = IConsoleLine::Get(IConsoleWindow::scroll);

   172

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

   173

		for (int i = 0; i < max && print != NULL; i++, print = print->previous) {

   174

			DoDrawString(print->buffer, 5,

   175

				this->height - (2 + i) * ICON_LINE_HEIGHT, print->colour);

   176

		}

   177

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

   178

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

   179

		if (delta > 0) {

   180

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

   181

			delta = 0;

   182

		}

   183

   184

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

   185

   186

		if (_iconsole_cmdline.caret) {

   187

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

   188

		}

   189

	}

   190

   191

	virtual void OnHundredthTick()

   192

	{

   193

		if (IConsoleLine::Truncate() &&

   194

				(IConsoleWindow::scroll > IConsoleLine::size)) {

   195

			IConsoleWindow::scroll = max(0, IConsoleLine::size - (this->height / ICON_LINE_HEIGHT) + 1);

   196

			this->SetDirty();

   197

		}

   198

	}

   199

   200

	virtual void OnMouseLoop()

   201

	{

   202

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

   203

	}

   204

   205

	virtual EventState OnKeyPress(uint16 key, uint16 keycode)

   206

	{

   207

		const int scroll_height = (this->height / ICON_LINE_HEIGHT) - 1;

   208

		switch (keycode) {

   209

			case WKC_UP:

   210

				IConsoleHistoryNavigate(+1);

   211

				this->SetDirty();

   212

				break;

   213

   214

			case WKC_DOWN:

   215

				IConsoleHistoryNavigate(-1);

   216

				this->SetDirty();

   217

				break;

   218

   219

			case WKC_SHIFT | WKC_PAGEDOWN:

   220

				if (IConsoleWindow::scroll - scroll_height < 0) {

   221

					IConsoleWindow::scroll = 0;

   222

				} else {

   223

					IConsoleWindow::scroll -= scroll_height;

   224

				}

   225

				this->SetDirty();

   226

				break;

   227

   228

			case WKC_SHIFT | WKC_PAGEUP:

   229

				if (IConsoleWindow::scroll + scroll_height > IConsoleLine::size - scroll_height) {

   230

					IConsoleWindow::scroll = IConsoleLine::size - scroll_height;

   231

				} else {

   232

					IConsoleWindow::scroll += scroll_height;

   233

				}

   234

				this->SetDirty();

   235

				break;

   236

   237

			case WKC_SHIFT | WKC_DOWN:

   238

				if (IConsoleWindow::scroll <= 0) {

   239

					IConsoleWindow::scroll = 0;

   240

				} else {

   241

					--IConsoleWindow::scroll;

   242

				}

   243

				this->SetDirty();

   244

				break;

   245

   246

			case WKC_SHIFT | WKC_UP:

   247

				if (IConsoleWindow::scroll >= IConsoleLine::size) {

   248

					IConsoleWindow::scroll = IConsoleLine::size;

   249

				} else {

   250

					++IConsoleWindow::scroll;

   251

				}

   252

				this->SetDirty();

   253

				break;

   254

   255

			case WKC_BACKQUOTE:

   256

				IConsoleSwitch();

   257

				break;

   258

   259

			case WKC_RETURN: case WKC_NUM_ENTER:

   260

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

   261

				IConsoleHistoryAdd(_iconsole_cmdline.buf);

   262

   263

				IConsoleCmdExec(_iconsole_cmdline.buf);

   264

				IConsoleClearCommand();

   265

				break;

   266

   267

			case WKC_CTRL | WKC_RETURN:

   268

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

   269

				IConsoleResize(this);

   270

				MarkWholeScreenDirty();

   271

				break;

   272

   273

			case (WKC_CTRL | 'V'):

   274

				if (InsertTextBufferClipboard(&_iconsole_cmdline)) {

   275

					IConsoleResetHistoryPos();

   276

					this->SetDirty();

   277

				}

   278

				break;

   279

   280

			case (WKC_CTRL | 'L'):

   281

				IConsoleCmdExec("clear");

   282

				break;

   283

   284

			case (WKC_CTRL | 'U'):

   285

				DeleteTextBufferAll(&_iconsole_cmdline);

   286

				this->SetDirty();

   287

				break;

   288

   289

			case WKC_BACKSPACE: case WKC_DELETE:

   290

				if (DeleteTextBufferChar(&_iconsole_cmdline, keycode)) {

   291

					IConsoleResetHistoryPos();

   292

					this->SetDirty();

   293

				}

   294

				break;

   295

   296

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

   297

				if (MoveTextBufferPos(&_iconsole_cmdline, keycode)) {

   298

					IConsoleResetHistoryPos();

   299

					this->SetDirty();

   300

				}

   301

				break;

   302

   303

			default:

   304

				if (IsValidChar(key, CS_ALPHANUMERAL)) {

   305

					IConsoleWindow::scroll = 0;

   306

					InsertTextBufferChar(&_iconsole_cmdline, key);

   307

					IConsoleResetHistoryPos();

   308

					this->SetDirty();

   309

				} else {

   310

					return ES_NOT_HANDLED;

   311

				}

   312

		}

   313

		return ES_HANDLED;

   314

	}

   315

};

   316

   317

int IConsoleWindow::scroll = 0;

   318

   319

static const Widget _iconsole_window_widgets[] = {

   320

	{WIDGETS_END}

   321

};

   322

   323

static const WindowDesc _iconsole_window_desc = {

   324

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

   325

	WC_CONSOLE, WC_NONE,

   326

	WDF_STD_TOOLTIPS | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS,

   327

	_iconsole_window_widgets,

   328

};

   329

   330

void IConsoleGUIInit()

   331

{

   332

	_iconsole_historypos = ICON_HISTORY_SIZE - 1;

   333

	_iconsole_mode = ICONSOLE_CLOSED;

   334

   335

	IConsoleLine::Reset();

   336

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

   337

   338

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

   339

	_iconsole_cmdline.maxsize = ICON_CMDLN_SIZE;

   340

   341

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

   342

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

   343

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

   344

	IConsolePrint(CC_WHITE,  "");

   345

	IConsoleClearCommand();

   346

	IConsoleHistoryAdd("");

   347

}

   348

   349

void IConsoleClearBuffer()

   350

{

   351

	IConsoleLine::Reset();

   352

}

   353

   354

void IConsoleGUIFree()

   355

{

   356

	free(_iconsole_cmdline.buf);

   357

	IConsoleClearBuffer();

   358

}

   359

   360

void IConsoleResize(Window *w)

   361

{

   362

	switch (_iconsole_mode) {

   363

		case ICONSOLE_OPENED:

   364

			w->height = _screen.height / 3;

   365

			w->width = _screen.width;

   366

			break;

   367

		case ICONSOLE_FULL:

   368

			w->height = _screen.height - ICON_BOTTOM_BORDERWIDTH;

   369

			w->width = _screen.width;

   370

			break;

   371

		default: return;

   372

	}

   373

   374

	MarkWholeScreenDirty();

   375

}

   376

   377

void IConsoleSwitch()

   378

{

   379

	switch (_iconsole_mode) {

   380

		case ICONSOLE_CLOSED:

   381

			new IConsoleWindow(&_iconsole_window_desc);

   382

			break;

   383

   384

		case ICONSOLE_OPENED: case ICONSOLE_FULL:

   385

			DeleteWindowById(WC_CONSOLE, 0);

   386

			break;

   387

	}

   388

   389

	MarkWholeScreenDirty();

   390

}

   391

   392

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

   393

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

   394

   395

/**

   396

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

   397

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

   398

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

   399

 */

   400

static void IConsoleHistoryAdd(const char *cmd)

   401

{

   402

	free(_iconsole_history[ICON_HISTORY_SIZE - 1]);

   403

   404

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

   405

	_iconsole_history[0] = strdup(cmd);

   406

	IConsoleResetHistoryPos();

   407

}

   408

   409

/**

   410

 * Navigate Up/Down in the history of typed commands

   411

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

   412

 */

   413

static void IConsoleHistoryNavigate(int direction)

   414

{

   415

	int i = _iconsole_historypos + direction;

   416

   417

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

   418

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

   419

	if (i >= ICON_HISTORY_SIZE) i = 0;

   420

   421

	if (direction > 0) {

   422

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

   423

	}

   424

   425

	if (direction < 0) {

   426

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

   427

	}

   428

   429

	_iconsole_historypos = i;

   430

	IConsoleClearCommand();

   431

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

   432

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

   433

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

   434

	UpdateTextBufferSize(&_iconsole_cmdline);

   435

}

   436

   437

/**

   438

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

   439

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

   440

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

   441

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

   442

 * used as a history to print them onscreen

   443

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

   444

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

   445

 */

   446

void IConsoleGUIPrint(ConsoleColour color_code, char *str)

   447

{

   448

	new IConsoleLine(str, color_code);

   449

	SetWindowDirty(FindWindowById(WC_CONSOLE, 0));

   450

}