1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "table/strings.h"

     4

#include "window.h"

     5

#include "gui.h"

     6

#include "gfx.h"

     7

#include "player.h"

     8

#include "variables.h"

     9

#include "hal.h"

    10

#include <stdarg.h>

    11

#include <string.h>

    12

#include "console.h"

    13

    14

#ifdef WIN32

    15

#include <windows.h>

    16

#endif

    17

    18

#define ICON_BUFFER 79

    19

#define ICON_CMDBUF_SIZE 20

    20

#define ICON_CMDLN_SIZE 255

    21

#define ICON_LINE_HEIGHT 12

    22

    23

typedef enum {

    24

	ICONSOLE_OPENED,

    25

	ICONSOLE_CLOSED

    26

} _iconsole_modes;

    27

    28

// ** main console ** //

    29

static bool _iconsole_inited;

    30

static char* _iconsole_buffer[ICON_BUFFER + 1];

    31

static char _iconsole_cbuffer[ICON_BUFFER + 1];

    32

static char _iconsole_cmdline[ICON_CMDLN_SIZE];

    33

static byte _iconsole_cmdpos;

    34

static _iconsole_modes _iconsole_mode = ICONSOLE_CLOSED;

    35

static Window* _iconsole_win = NULL;

    36

static byte _iconsole_scroll;

    37

    38

// ** console cursor ** //

    39

static bool _icursor_state;

    40

static byte _icursor_rate;

    41

static byte _icursor_counter;

    42

    43

// ** stdlib ** //

    44

byte _stdlib_developer = 1;

    45

bool _stdlib_con_developer = false;

    46

FILE* _iconsole_output_file;

    47

    48

// ** main console cmd buffer

    49

static char* _iconsole_cmdbuffer[ICON_CMDBUF_SIZE];

    50

static byte _iconsole_cmdbufferpos;

    51

    52

// ** console window ** //

    53

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

    54

static const Widget _iconsole_window_widgets[] = {

    55

	{WIDGETS_END}

    56

};

    57

static const WindowDesc _iconsole_window_desc = {

    58

	0, 0, 2, 2,

    59

	WC_CONSOLE, 0,

    60

	WDF_STD_TOOLTIPS | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS,

    61

	_iconsole_window_widgets,

    62

	IConsoleWndProc,

    63

};

    64

    65

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

    66

/*  end of header  */

    67

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

    68

    69

static void IConsoleAppendClipboard(void)

    70

{

    71

#ifdef WIN32

    72

	if (IsClipboardFormatAvailable(CF_TEXT)) {

    73

		const char* data;

    74

		HGLOBAL cbuf;

    75

    76

		OpenClipboard(NULL);

    77

		cbuf = GetClipboardData(CF_TEXT);

    78

		data = GlobalLock(cbuf);

    79

    80

		/* IS_INT_INSIDE = filter for ascii-function codes like BELL and so on [we need an special filter here later] */

    81

		for (; (IS_INT_INSIDE(*data, ' ', 256)) && (_iconsole_cmdpos < lengthof(_iconsole_cmdline) - 1); ++data)

    82

			_iconsole_cmdline[_iconsole_cmdpos++] = *data;

    83

    84

		GlobalUnlock(cbuf);

    85

		CloseClipboard();

    86

	}

    87

#endif

    88

}

    89

    90

static void IConsoleClearCommand(void)

    91

{

    92

	memset(_iconsole_cmdline, 0, sizeof(_iconsole_cmdline));

    93

	_iconsole_cmdpos = 0;

    94

	SetWindowDirty(_iconsole_win);

    95

}

    96

    97

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

    98

{

    99

	// only do window events with the console

   100

	w = FindWindowById(WC_CONSOLE, 0);

   101

   102

	switch(e->event) {

   103

		case WE_PAINT:

   104

		{

   105

			int i = _iconsole_scroll;

   106

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

   107

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

   108

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

   109

				DoDrawString(_iconsole_buffer[i], 5,

   110

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

   111

				i--;

   112

			}

   113

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

   114

			DoDrawString(_iconsole_cmdline, 10, w->height - ICON_LINE_HEIGHT, _iconsole_color_commands);

   115

			break;

   116

		}

   117

		case WE_TICK:

   118

			_icursor_counter++;

   119

			if (_icursor_counter > _icursor_rate) {

   120

				int posx;

   121

				int posy;

   122

   123

				_icursor_state = !_icursor_state;

   124

   125

				_cur_dpi = &_screen;

   126

				posx = 10 + GetStringWidth(_iconsole_cmdline);

   127

				posy = w->height - 3;

   128

				GfxFillRect(posx, posy, posx + 5, posy + 1, _icursor_state ? 14 : 0);

   129

				_video_driver->make_dirty(posx, posy, 5, 1);

   130

				_icursor_counter = 0;

   131

			}

   132

			break;

   133

		case WE_DESTROY:

   134

			_iconsole_win = NULL;

   135

			_iconsole_mode = ICONSOLE_CLOSED;

   136

			break;

   137

		case WE_KEYPRESS:

   138

		{

   139

			e->keypress.cont = false;

   140

			switch (e->keypress.keycode) {

   141

				case WKC_CTRL | 'V':

   142

					IConsoleAppendClipboard();

   143

					SetWindowDirty(w);

   144

					break;

   145

				case WKC_UP:

   146

					IConsoleCmdBufferNavigate(+1);

   147

					SetWindowDirty(w);

   148

					break;

   149

				case WKC_DOWN:

   150

					IConsoleCmdBufferNavigate(-1);

   151

					SetWindowDirty(w);

   152

					break;

   153

				case WKC_SHIFT | WKC_PAGEUP:

   154

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

   155

						_iconsole_scroll = 0;

   156

					else

   157

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

   158

					SetWindowDirty(w);

   159

					break;

   160

				case WKC_SHIFT | WKC_PAGEDOWN:

   161

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

   162

						_iconsole_scroll = ICON_BUFFER;

   163

					else

   164

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

   165

					SetWindowDirty(w);

   166

					break;

   167

				case WKC_SHIFT | WKC_UP:

   168

					if (_iconsole_scroll <= 0)

   169

						_iconsole_scroll = 0;

   170

					else

   171

						--_iconsole_scroll;

   172

					SetWindowDirty(w);

   173

					break;

   174

				case WKC_SHIFT | WKC_DOWN:

   175

					if (_iconsole_scroll >= ICON_BUFFER)

   176

						_iconsole_scroll = ICON_BUFFER;

   177

					else

   178

						++_iconsole_scroll;

   179

					SetWindowDirty(w);

   180

					break;

   181

				case WKC_BACKQUOTE:

   182

					IConsoleSwitch();

   183

					break;

   184

				case WKC_RETURN:

   185

					IConsolePrintF(_iconsole_color_commands, "] %s", _iconsole_cmdline);

   186

					IConsoleCmdBufferAdd(_iconsole_cmdline);

   187

					IConsoleCmdExec(_iconsole_cmdline);

   188

					IConsoleClearCommand();

   189

					break;

   190

				case WKC_BACKSPACE:

   191

					if (_iconsole_cmdpos != 0) _iconsole_cmdpos--;

   192

					_iconsole_cmdline[_iconsole_cmdpos] = 0;

   193

					SetWindowDirty(w);

   194

					_iconsole_cmdbufferpos = 19;

   195

					break;

   196

				default:

   197

					/* IS_INT_INSIDE = filter for ascii-function codes like BELL and so on [we need an special filter here later] */

   198

					if (IS_INT_INSIDE(e->keypress.ascii, ' ', 256)) {

   199

						_iconsole_scroll = ICON_BUFFER;

   200

						_iconsole_cmdline[_iconsole_cmdpos] = e->keypress.ascii;

   201

						if (_iconsole_cmdpos != lengthof(_iconsole_cmdline))

   202

							_iconsole_cmdpos++;

   203

						SetWindowDirty(w);

   204

						_iconsole_cmdbufferpos = ICON_CMDBUF_SIZE - 1;

   205

					}

   206

					else

   207

						e->keypress.cont = true;

   208

			}

   209

			break;

   210

		}

   211

	}

   212

}

   213

   214

void IConsoleInit(void)

   215

{

   216

	uint i;

   217

	#if defined(WITH_REV)

   218

	extern char _openttd_revision[];

   219

	#endif

   220

	_iconsole_output_file = NULL;

   221

	_iconsole_color_default = 1;

   222

	_iconsole_color_error = 3;

   223

	_iconsole_color_warning = 13;

   224

	_iconsole_color_debug = 5;

   225

	_iconsole_color_commands = 2;

   226

	_iconsole_scroll = ICON_BUFFER;

   227

	_iconsole_cmdbufferpos = ICON_CMDBUF_SIZE - 1;

   228

	_iconsole_inited = true;

   229

	_iconsole_mode = ICONSOLE_CLOSED;

   230

	_iconsole_win = NULL;

   231

	_icursor_state = false;

   232

	_icursor_rate = 5;

   233

	_icursor_counter = 0;

   234

	for (i = 0; i < lengthof(_iconsole_cmdbuffer); i++)

   235

		_iconsole_cmdbuffer[i] = NULL;

   236

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

   237

		_iconsole_buffer[i] = NULL;

   238

		_iconsole_cbuffer[i] = 0;

   239

	}

   240

	IConsoleStdLibRegister();

   241

	#if defined(WITH_REV)

   242

	IConsolePrintF(13, "OpenTTD Game Console Revision 4 - %s", _openttd_revision);

   243

	#else

   244

	IConsolePrint(13, "OpenTTD Game Console Revision 4");

   245

	#endif

   246

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

   247

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

   248

	IConsolePrint(12, "");

   249

	IConsoleClearCommand();

   250

	IConsoleCmdBufferAdd("");

   251

}

   252

   253

void IConsoleClear(void)

   254

{

   255

	uint i;

   256

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

   257

		free(_iconsole_buffer[i]);

   258

}

   259

   260

void IConsoleFree(void)

   261

{

   262

	_iconsole_inited = false;

   263

	IConsoleClear();

   264

	if (_iconsole_output_file != NULL) fclose(_iconsole_output_file);

   265

}

   266

   267

void IConsoleResize(void)

   268

{

   269

	if (_iconsole_win != NULL) {

   270

		_iconsole_win->height = _screen.height / 3;

   271

		_iconsole_win->width = _screen.width;

   272

	}

   273

}

   274

   275

void IConsoleSwitch(void)

   276

{

   277

	switch (_iconsole_mode) {

   278

		case ICONSOLE_CLOSED:

   279

			_iconsole_win = AllocateWindowDesc(&_iconsole_window_desc);

   280

			_iconsole_win->height = _screen.height / 3;

   281

			_iconsole_win->width = _screen.width;

   282

			_iconsole_mode = ICONSOLE_OPENED;

   283

			break;

   284

		case ICONSOLE_OPENED:

   285

			DeleteWindowById(WC_CONSOLE, 0);

   286

			_iconsole_win = NULL;

   287

			_iconsole_mode = ICONSOLE_CLOSED;

   288

			break;

   289

	}

   290

	MarkWholeScreenDirty();

   291

	MarkAllViewportsDirty(0, 0, _screen.width, _screen.height);

   292

	_video_driver->make_dirty(0, 0, _screen.width, _screen.height);

   293

}

   294

   295

void IConsoleClose(void)

   296

{

   297

	if (_iconsole_mode == ICONSOLE_OPENED) IConsoleSwitch();

   298

	_iconsole_mode = ICONSOLE_CLOSED;

   299

}

   300

   301

void IConsoleOpen(void)

   302

{

   303

	if (_iconsole_mode == ICONSOLE_CLOSED) IConsoleSwitch();

   304

	_iconsole_mode = ICONSOLE_OPENED;

   305

}

   306

   307

void IConsoleCmdBufferAdd(const char* cmd)

   308

{

   309

	int i;

   310

	if (_iconsole_cmdbufferpos != 19) return;

   311

	free(_iconsole_cmdbuffer[18]);

   312

	for (i = 18; i > 0; i--) _iconsole_cmdbuffer[i] = _iconsole_cmdbuffer[i - 1];

   313

	_iconsole_cmdbuffer[0] = strdup(cmd);

   314

}

   315

   316

void IConsoleCmdBufferNavigate(signed char direction)

   317

{

   318

	int i;

   319

	i = _iconsole_cmdbufferpos + direction;

   320

	if (i < 0) i = 19;

   321

	if (i > 19) i = 0;

   322

	if (direction > 0)

   323

		while (_iconsole_cmdbuffer[i] == NULL) {

   324

			++i;

   325

			if (i > 19) i = 0;

   326

		}

   327

	if (direction < 0)

   328

		while (_iconsole_cmdbuffer[i] == NULL) {

   329

			--i;

   330

			if (i < 0) i = 19;

   331

		}

   332

	_iconsole_cmdbufferpos = i;

   333

	IConsoleClearCommand();

   334

	memcpy(_iconsole_cmdline, _iconsole_cmdbuffer[i],

   335

		strlen(_iconsole_cmdbuffer[i]));

   336

	_iconsole_cmdpos = strlen(_iconsole_cmdbuffer[i]);

   337

}

   338

   339

void IConsolePrint(byte color_code, const char* string)

   340

{

   341

	char* _ex;

   342

	char* _new;

   343

	char _exc;

   344

	char _newc;

   345

	char* i;

   346

	int j;

   347

   348

	if (!_iconsole_inited) return;

   349

   350

	_newc = color_code;

   351

	_new = strdup(string);

   352

   353

	for (i = _new; *i != '\0'; ++i)

   354

		if (*i < ' ') *i = ' '; /* filter for ascii-function codes like BELL and so on [we need an special filter here later] */

   355

   356

	for (j = ICON_BUFFER; j >= 0; --j) {

   357

		_ex = _iconsole_buffer[j];

   358

		_exc = _iconsole_cbuffer[j];

   359

		_iconsole_buffer[j] = _new;

   360

		_iconsole_cbuffer[j] = _newc;

   361

		_new = _ex;

   362

		_newc = _exc;

   363

	}

   364

	free(_ex);

   365

   366

	if (_iconsole_win != NULL) SetWindowDirty(_iconsole_win);

   367

}

   368

   369

   370

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

   371

{

   372

	va_list va;

   373

	char buf[1024];

   374

	int len;

   375

   376

	va_start(va, s);

   377

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

   378

	va_end(va);

   379

   380

	IConsolePrint(color_code, buf);

   381

   382

	if (_iconsole_output_file != NULL) {

   383

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

   384

		fwrite(buf, len, 1, _iconsole_output_file);

   385

		fwrite("\n", 1, 1, _iconsole_output_file);

   386

	}

   387

}

   388

   389

void IConsoleDebug(const char* string)

   390

{

   391

	if (_stdlib_developer > 1)

   392

		IConsolePrintF(_iconsole_color_debug, "DEBUG: %s", string);

   393

}

   394

   395

void IConsoleError(const char* string)

   396

{

   397

	if (_stdlib_developer > 0)

   398

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

   399

}

   400

   401

void IConsoleWarning(const char* string)

   402

{

   403

	if (_stdlib_developer > 0)

   404

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

   405

}

   406

   407

void IConsoleCmdRegister(const char* name, _iconsole_cmd_addr addr)

   408

{

   409

	char* _new;

   410

	_iconsole_cmd* item;

   411

	_iconsole_cmd* item_new;

   412

   413

	_new = strdup(name);

   414

   415

	item_new = malloc(sizeof(_iconsole_cmd));

   416

   417

	item_new->_next = NULL;

   418

	item_new->addr = addr;

   419

	item_new->name = _new;

   420

   421

	item_new->hook_access = NULL;

   422

	item_new->hook_after_exec = NULL;

   423

	item_new->hook_before_exec = NULL;

   424

   425

	item = _iconsole_cmds;

   426

	if (item == NULL) {

   427

		_iconsole_cmds = item_new;

   428

	} else {

   429

		while (item->_next != NULL) item = item->_next;

   430

		item->_next = item_new;

   431

	}

   432

}

   433

   434

_iconsole_cmd* IConsoleCmdGet(const char* name)

   435

{

   436

	_iconsole_cmd* item;

   437

   438

	item = _iconsole_cmds;

   439

	while (item != NULL) {

   440

		if (strcmp(item->name, name) == 0) return item;

   441

		item = item->_next;

   442

	}

   443

	return NULL;

   444

}

   445

   446

void IConsoleVarRegister(const char* name, void* addr, _iconsole_var_types type)

   447

{

   448

	_iconsole_var* item;

   449

	_iconsole_var* item_new;

   450

   451

	item_new = malloc(sizeof(_iconsole_var)); /* XXX unchecked malloc */

   452

   453

	item_new->name = malloc(strlen(name) + 2); /* XXX unchecked malloc */

   454

	sprintf(item_new->name, "*%s", name);

   455

   456

	item_new->_next = NULL;

   457

	switch (type) {

   458

		case ICONSOLE_VAR_BOOLEAN:

   459

			item_new->data.bool_ = addr;

   460

			break;

   461

		case ICONSOLE_VAR_BYTE:

   462

			item_new->data.byte_ = addr;

   463

			break;

   464

		case ICONSOLE_VAR_UINT16:

   465

			item_new->data.uint16_ = addr;

   466

			break;

   467

		case ICONSOLE_VAR_UINT32:

   468

			item_new->data.uint32_ = addr;

   469

			break;

   470

		case ICONSOLE_VAR_INT16:

   471

			item_new->data.int16_ = addr;

   472

			break;

   473

		case ICONSOLE_VAR_INT32:

   474

			item_new->data.int32_ = addr;

   475

			break;

   476

		case ICONSOLE_VAR_STRING:

   477

			item_new->data.string_ = addr;

   478

			break;

   479

		default:

   480

			error("unknown console variable type");

   481

			break;

   482

	}

   483

	item_new->type = type;