1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "window.h"

     4

#include "gui.h"

     5

#include "gfx.h"

     6

#include "player.h"

     7

#include "variables.h"

     8

#include "hal.h"

     9

#include <stdarg.h>

    10

#include <string.h>

    11

#include "console.h"

    12

    13

#ifdef WIN32

    14

#include <windows.h>

    15

#endif

    16

    17

#define ICONSOLE_BUFFER_SIZE 80

    18

    19

typedef enum {

    20

	ICONSOLE_OPENED,

    21

	ICONSOLE_CLOSED

    22

} _iconsole_modes;

    23

    24

// ** main console ** //

    25

static bool _iconsole_inited;

    26

static char* _iconsole_buffer[ICONSOLE_BUFFER_SIZE];

    27

static char _iconsole_cbuffer[ICONSOLE_BUFFER_SIZE];

    28

static char _iconsole_cmdline[255];

    29

static byte _iconsole_cmdpos;

    30

static _iconsole_modes _iconsole_mode = ICONSOLE_CLOSED;

    31

static Window* _iconsole_win = NULL;

    32

static byte _iconsole_scroll;

    33

    34

// ** console cursor ** //

    35

static bool _icursor_state;

    36

static byte _icursor_rate;

    37

static byte _icursor_counter;

    38

    39

// ** stdlib ** //

    40

byte _stdlib_developer = 1;

    41

bool _stdlib_con_developer = false;

    42

FILE* _iconsole_output_file;

    43

    44

// ** main console cmd buffer ** // sign_de: especially for Celestar :D

    45

static char* _iconsole_cmdbuffer[20];

    46

static byte _iconsole_cmdbufferpos;

    47

    48

// ** console window ** //

    49

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

    50

static const Widget _iconsole_window_widgets[] = {

    51

	{WIDGETS_END}

    52

};

    53

static const WindowDesc _iconsole_window_desc = {

    54

	0, 0, 2, 2,

    55

	WC_CONSOLE, 0,

    56

	WDF_STD_TOOLTIPS | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS,

    57

	_iconsole_window_widgets,

    58

	IConsoleWndProc,

    59

};

    60

    61

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

    62

/*  end of header  */

    63

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

    64

    65

static void IConsoleAppendClipboard(void)

    66

{

    67

#ifdef WIN32

    68

	if (IsClipboardFormatAvailable(CF_TEXT)) {

    69

		const char* data;

    70

		HGLOBAL cbuf;

    71

    72

		OpenClipboard(NULL);

    73

		cbuf = GetClipboardData(CF_TEXT);

    74

		data = GlobalLock(cbuf);

    75

    76

		for (; IS_INT_INSIDE(*data, 32, 256); ++data) /* XXX magic numbers */

    77

			_iconsole_cmdline[_iconsole_cmdpos++] = *data; /* XXX prone to buffer overflow */

    78

    79

		GlobalUnlock(cbuf);

    80

		CloseClipboard();

    81

	}

    82

#endif

    83

}

    84

    85

static void IConsoleClearCommand(void)

    86

{

    87

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

    88

	_iconsole_cmdpos = 0;

    89

	SetWindowDirty(_iconsole_win);

    90

}

    91

    92

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

    93

{

    94

	// only do window events with the console

    95

	w = FindWindowById(WC_CONSOLE, 0);

    96

    97

	switch(e->event) {

    98

		case WE_PAINT:

    99

		{

   100

			int i = _iconsole_scroll;

   101

			int max = w->height / 12 - 1;

   102

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

   103

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

   104

				DoDrawString(_iconsole_buffer[i], 5,

   105

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

   106

				i--;

   107

			}

   108

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

   109

			DoDrawString(_iconsole_cmdline, 10, w->height - 12,

   110

				_iconsole_color_commands);

   111

			break;

   112

		}

   113

		case WE_TICK:

   114

			_icursor_counter++;

   115

			if (_icursor_counter > _icursor_rate) {

   116

				int posx;

   117

				int posy;

   118

   119

				_icursor_state = !_icursor_state;

   120

   121

				_cur_dpi = &_screen;

   122

				posx = 10 + GetStringWidth(_iconsole_cmdline);

   123

				posy = w->height - 3;

   124

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

   125

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

   126

				_icursor_counter = 0;

   127

			}

   128

			break;

   129

		case WE_DESTROY:

   130

			_iconsole_win = NULL;

   131

			_iconsole_mode = ICONSOLE_CLOSED;

   132

			break;

   133

		case WE_KEYPRESS:

   134

		{

   135

			e->keypress.cont = false;

   136

			switch (e->keypress.keycode) {

   137

				case WKC_CTRL | 'V':

   138

					IConsoleAppendClipboard();

   139

					SetWindowDirty(w);

   140

					break;

   141

				case WKC_UP:

   142

					IConsoleCmdBufferNavigate(+1);

   143

					SetWindowDirty(w);

   144

					break;

   145

				case WKC_DOWN:

   146

					IConsoleCmdBufferNavigate(-1);

   147

					SetWindowDirty(w);

   148

					break;

   149

				case WKC_SHIFT | WKC_PAGEUP:

   150

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

   151

						_iconsole_scroll = 0;

   152

					else

   153

						_iconsole_scroll -= w->height / 12 - 1;

   154

					SetWindowDirty(w);

   155

					break;

   156

				case WKC_SHIFT | WKC_PAGEDOWN:

   157

					if (_iconsole_scroll + w->height / 12 - 1 > 79) /* XXX magic number */

   158

						_iconsole_scroll = 79; /* XXX magic number */

   159

					else

   160

						_iconsole_scroll += w->height / 12 - 1;

   161

					SetWindowDirty(w);

   162

					break;

   163

				case WKC_SHIFT | WKC_UP:

   164

					if (_iconsole_scroll <= 0)

   165

						_iconsole_scroll = 0;

   166

					else

   167

						--_iconsole_scroll;

   168

					SetWindowDirty(w);

   169

					break;

   170

				case WKC_SHIFT | WKC_DOWN:

   171

					if (_iconsole_scroll >= 79) /* XXX magic number */

   172

						_iconsole_scroll = 79; /* XXX magic number */

   173

					else

   174

						++_iconsole_scroll;

   175

					SetWindowDirty(w);

   176

					break;

   177

				case WKC_BACKQUOTE:

   178

					IConsoleSwitch();

   179

					break;

   180

				case WKC_RETURN:

   181

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

   182

					IConsoleCmdBufferAdd(_iconsole_cmdline);

   183

					IConsoleCmdExec(_iconsole_cmdline);

   184

					IConsoleClearCommand();

   185

					break;

   186

				case WKC_BACKSPACE:

   187

					if (_iconsole_cmdpos != 0) _iconsole_cmdpos--;

   188

					_iconsole_cmdline[_iconsole_cmdpos] = 0;

   189

					SetWindowDirty(w);

   190

					_iconsole_cmdbufferpos = 19;

   191

					break;

   192

				default:

   193

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

   194

						_iconsole_scroll = 79; /* XXX magic number */

   195

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

   196

						if (_iconsole_cmdpos != sizeof(_iconsole_cmdline))

   197

							_iconsole_cmdpos++;

   198

						SetWindowDirty(w);

   199

						_iconsole_cmdbufferpos = 19;

   200

					}

   201

					else

   202

						e->keypress.cont = true;

   203

			}

   204

			break;

   205

		}

   206

	}

   207

}

   208

   209

void IConsoleInit(void)

   210

{

   211

	uint i;

   212

	#if defined(WITH_REV)

   213

	extern char _openttd_revision[];

   214

	#endif

   215

	_iconsole_output_file = NULL;

   216

	_iconsole_color_default = 1;

   217

	_iconsole_color_error = 3;

   218

	_iconsole_color_warning = 13;

   219

	_iconsole_color_debug = 5;

   220

	_iconsole_color_commands = 2;

   221

	_iconsole_scroll = 79; /* XXX magic number */

   222

	_iconsole_cmdbufferpos = 19; /* XXX magic number */

   223

	_iconsole_inited = true;

   224

	_iconsole_mode = ICONSOLE_CLOSED;

   225

	_iconsole_win = NULL;

   226

	_icursor_state = false;

   227

	_icursor_rate = 5;

   228

	_icursor_counter = 0;

   229

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

   230

		_iconsole_cmdbuffer[i] = NULL;

   231

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

   232

		_iconsole_buffer[i] = NULL;

   233

		_iconsole_cbuffer[i] = 0;

   234

	}

   235

	IConsoleStdLibRegister();

   236

	#if defined(WITH_REV)

   237

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

   238

	#else

   239

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

   240

	#endif

   241

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

   242

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

   243

	IConsolePrint(12, "");

   244

	IConsoleClearCommand();

   245

	IConsoleCmdBufferAdd("");

   246

}

   247

   248

void IConsoleClear(void)

   249

{

   250

	uint i;

   251

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

   252

		free(_iconsole_buffer[i]);

   253

}

   254

   255

void IConsoleFree(void)

   256

{

   257

	_iconsole_inited = false;

   258

	IConsoleClear();

   259

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

   260

}

   261

   262

void IConsoleResize(void)

   263

{

   264

	if (_iconsole_win != NULL) {

   265

		_iconsole_win->height = _screen.height / 3;

   266

		_iconsole_win->width = _screen.width;

   267

	}

   268

}

   269

   270

void IConsoleSwitch(void)

   271

{

   272

	switch (_iconsole_mode) {

   273

		case ICONSOLE_CLOSED:

   274

			_iconsole_win = AllocateWindowDesc(&_iconsole_window_desc);

   275

			_iconsole_win->height = _screen.height / 3;

   276

			_iconsole_win->width = _screen.width;

   277

			_iconsole_mode = ICONSOLE_OPENED;

   278

			break;

   279

		case ICONSOLE_OPENED:

   280

			DeleteWindowById(WC_CONSOLE, 0);

   281

			_iconsole_win = NULL;

   282

			_iconsole_mode = ICONSOLE_CLOSED;

   283

			break;

   284

	}

   285

	MarkWholeScreenDirty();

   286

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

   287

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

   288

}

   289

   290

void IConsoleClose(void)

   291

{

   292

	if (_iconsole_mode == ICONSOLE_OPENED) IConsoleSwitch();

   293

	_iconsole_mode = ICONSOLE_CLOSED;

   294

}

   295

   296

void IConsoleOpen(void)

   297

{

   298

	if (_iconsole_mode == ICONSOLE_CLOSED) IConsoleSwitch();

   299

	/* XXX missing _iconsole_mode ? */

   300

}

   301

   302

void IConsoleCmdBufferAdd(const char* cmd)

   303

{

   304

	int i;

   305

	if (_iconsole_cmdbufferpos != 19) return;

   306

	free(_iconsole_cmdbuffer[18]);

   307

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

   308

	_iconsole_cmdbuffer[0] = strdup(cmd);

   309

}

   310

   311

void IConsoleCmdBufferNavigate(signed char direction)

   312

{

   313

	int i;

   314

	i = _iconsole_cmdbufferpos + direction;

   315

	if (i < 0) i = 19;

   316

	if (i > 19) i = 0;

   317

	if (direction > 0)

   318

		while (_iconsole_cmdbuffer[i] == NULL) {

   319

			++i;

   320

			if (i > 19) i = 0;

   321

		}

   322

	if (direction < 0)

   323

		while (_iconsole_cmdbuffer[i] == NULL) {

   324

			--i;

   325

			if (i < 0) i = 19;

   326

		}

   327

	_iconsole_cmdbufferpos = i;

   328

	IConsoleClearCommand();

   329

	memcpy(_iconsole_cmdline, _iconsole_cmdbuffer[i],

   330

		strlen(_iconsole_cmdbuffer[i]));

   331

	_iconsole_cmdpos = strlen(_iconsole_cmdbuffer[i]);

   332

}

   333

   334

void IConsolePrint(byte color_code, const char* string)

   335

{

   336

	char* _ex;

   337

	char* _new;

   338

	char _exc;

   339

	char _newc;

   340

	char* i;

   341

	int j;

   342

   343

	if (!_iconsole_inited) return;

   344

   345

	_newc = color_code;

   346

	_new = strdup(string);

   347

   348

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

   349

		if (*i < 0x1F) *i = ' '; /* XXX 0x1F seems wrong + magic number */

   350

   351

	for (j = ICONSOLE_BUFFER_SIZE - 1; j >= 0; --j) {

   352

		_ex = _iconsole_buffer[j];

   353

		_exc = _iconsole_cbuffer[j];

   354

		_iconsole_buffer[j] = _new;

   355

		_iconsole_cbuffer[j] = _newc;

   356

		_new = _ex;

   357

		_newc = _exc;

   358

	}

   359

	free(_ex);

   360

   361

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

   362

}

   363

   364

   365

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

   366

{

   367

	va_list va;

   368

	char buf[1024];

   369

	int len;

   370

   371

	va_start(va, s);

   372

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

   373

	va_end(va);

   374

   375

	IConsolePrint(color_code, buf);

   376

   377

	if (_iconsole_output_file != NULL) {

   378

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

   379

		fwrite(buf, len, 1, _iconsole_output_file);

   380

		/* XXX why newline? */

   381

		buf[1023] = '\n';

   382

		fwrite(&buf[1023], 1, 1, _iconsole_output_file);

   383

	}

   384

}

   385

   386

void IConsoleDebug(const char* string)

   387

{

   388

	if (_stdlib_developer > 1)

   389

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

   390

}

   391

   392

void IConsoleError(const char* string)

   393

{

   394

	if (_stdlib_developer > 0)

   395

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

   396

}

   397

   398

void IConsoleWarning(const char* string)

   399

{

   400

	if (_stdlib_developer > 0)

   401

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

   402

}

   403

   404

void IConsoleCmdRegister(const char* name, _iconsole_cmd_addr addr)

   405

{

   406

	char* _new;

   407

	_iconsole_cmd* item;

   408

	_iconsole_cmd* item_new;

   409

   410

	_new = strdup(name);

   411

   412

	item_new = malloc(sizeof(_iconsole_cmd));

   413

   414

	item_new->_next = NULL;

   415

	item_new->addr = addr;

   416

	item_new->name = _new;

   417

   418

	item_new->hook_access = NULL;

   419

	item_new->hook_after_exec = NULL;

   420

	item_new->hook_before_exec = NULL;

   421

   422

	item = _iconsole_cmds;

   423

	if (item == NULL) {

   424

		_iconsole_cmds = item_new;

   425

	} else {

   426

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

   427

		item->_next = item_new;

   428

	}

   429

}

   430

   431

_iconsole_cmd* IConsoleCmdGet(const char* name)

   432

{

   433

	_iconsole_cmd* item;

   434

   435

	item = _iconsole_cmds;

   436

	while (item != NULL) {

   437

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

   438

		item = item->_next;

   439

	}

   440

	return NULL;

   441

}

   442

   443

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

   444

{

   445

	_iconsole_var* item;

   446

	_iconsole_var* item_new;

   447

   448

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

   449

   450

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

   451

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

   452

   453

	item_new->_next = NULL;

   454

	switch (type) {

   455

		case ICONSOLE_VAR_BOOLEAN:

   456

			item_new->data.bool_ = addr;

   457

			break;

   458

		case ICONSOLE_VAR_BYTE:

   459

			item_new->data.byte_ = addr;

   460

			break;

   461

		case ICONSOLE_VAR_UINT16:

   462

			item_new->data.uint16_ = addr;

   463

			break;

   464

		case ICONSOLE_VAR_UINT32:

   465

			item_new->data.uint32_ = addr;

   466

			break;

   467

		case ICONSOLE_VAR_INT16:

   468

			item_new->data.int16_ = addr;

   469

			break;

   470

		case ICONSOLE_VAR_INT32:

   471

			item_new->data.int32_ = addr;

   472

			break;

   473

		case ICONSOLE_VAR_STRING:

   474

			item_new->data.string_ = addr;

   475

			break;

   476

		default:

   477

			assert(0); /* XXX */

   478

			break;

   479

	}

   480

	item_new->type = type;

   481

	item_new->_malloc = false;

   482

   483

	item_new->hook_access = NULL;

   484

	item_new->hook_after_change = NULL;

   485

	item_new->hook_before_change = NULL;

   486