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

    21

    22

typedef enum {

    23

	ICONSOLE_OPENED,

    24

	ICONSOLE_CLOSED

    25

} _iconsole_modes;

    26

    27

// ** main console ** //

    28

static bool _iconsole_inited;

    32

static byte _iconsole_cmdpos;

    33

static _iconsole_modes _iconsole_mode = ICONSOLE_CLOSED;

    34

static Window* _iconsole_win = NULL;

    35

static byte _iconsole_scroll;

    36

    37

// ** console cursor ** //

    38

static bool _icursor_state;

    39

static byte _icursor_rate;

    40

static byte _icursor_counter;

    41

    42

// ** stdlib ** //

    43

byte _stdlib_developer = 1;

    44

bool _stdlib_con_developer = false;

    45

FILE* _iconsole_output_file;

    46

    49

static byte _iconsole_cmdbufferpos;

    50

    51

// ** console window ** //

    52

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

    53

static const Widget _iconsole_window_widgets[] = {

    54

	{WIDGETS_END}

    55

};

    56

static const WindowDesc _iconsole_window_desc = {

    57

	0, 0, 2, 2,

    58

	WC_CONSOLE, 0,

    59

	WDF_STD_TOOLTIPS | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS,

    60

	_iconsole_window_widgets,

    61

	IConsoleWndProc,

    62

};

    63

    64

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

    65

/*  end of header  */

    66

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

    67

    68

static void IConsoleAppendClipboard(void)

    69

{

    70

#ifdef WIN32

    71

	if (IsClipboardFormatAvailable(CF_TEXT)) {

    72

		const char* data;

    73

		HGLOBAL cbuf;

    74

    75

		OpenClipboard(NULL);

    76

		cbuf = GetClipboardData(CF_TEXT);

    77

		data = GlobalLock(cbuf);

    78

    82

    83

		GlobalUnlock(cbuf);

    84

		CloseClipboard();

    85

	}

    86

#endif

    87

}

    88

    89

static void IConsoleClearCommand(void)

    90

{

    91

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

    92

	_iconsole_cmdpos = 0;

    93

	SetWindowDirty(_iconsole_win);

    94

}

    95

    96

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

    97

{

    98

	// only do window events with the console

    99

	w = FindWindowById(WC_CONSOLE, 0);

   100

   101

	switch(e->event) {

   102

		case WE_PAINT:

   103

		{

   104

			int i = _iconsole_scroll;

   106

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

   107

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

   108

				DoDrawString(_iconsole_buffer[i], 5,

   110

				i--;

   111

			}

   114

			break;

   115

		}

   116

		case WE_TICK:

   117

			_icursor_counter++;

   118

			if (_icursor_counter > _icursor_rate) {

   119

				int posx;

   120

				int posy;

   121

   122

				_icursor_state = !_icursor_state;

   123

   124

				_cur_dpi = &_screen;

   125

				posx = 10 + GetStringWidth(_iconsole_cmdline);

   126

				posy = w->height - 3;

   127

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

   128

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

   129

				_icursor_counter = 0;

   130

			}

   131

			break;

   132

		case WE_DESTROY:

   133

			_iconsole_win = NULL;

   134

			_iconsole_mode = ICONSOLE_CLOSED;

   135

			break;

   136

		case WE_KEYPRESS:

   137

		{

   138

			e->keypress.cont = false;

   139

			switch (e->keypress.keycode) {

   140

				case WKC_CTRL | 'V':

   141

					IConsoleAppendClipboard();

   142

					SetWindowDirty(w);

   143

					break;

   144

				case WKC_UP:

   145

					IConsoleCmdBufferNavigate(+1);

   146

					SetWindowDirty(w);

   147

					break;

   148

				case WKC_DOWN:

   149

					IConsoleCmdBufferNavigate(-1);

   150

					SetWindowDirty(w);

   151

					break;

   152

				case WKC_SHIFT | WKC_PAGEUP:

   154

						_iconsole_scroll = 0;

   155

					else

   157

					SetWindowDirty(w);

   158

					break;

   159

				case WKC_SHIFT | WKC_PAGEDOWN:

   162

					else

   164

					SetWindowDirty(w);

   165

					break;

   166

				case WKC_SHIFT | WKC_UP:

   167

					if (_iconsole_scroll <= 0)

   168

						_iconsole_scroll = 0;

   169

					else

   170

						--_iconsole_scroll;

   171

					SetWindowDirty(w);

   172

					break;

   173

				case WKC_SHIFT | WKC_DOWN:

   176

					else

   177

						++_iconsole_scroll;

   178

					SetWindowDirty(w);

   179

					break;

   180

				case WKC_BACKQUOTE:

   181

					IConsoleSwitch();

   182

					break;

   183

				case WKC_RETURN:

   184

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

   185

					IConsoleCmdBufferAdd(_iconsole_cmdline);

   186

					IConsoleCmdExec(_iconsole_cmdline);

   187

					IConsoleClearCommand();

   188

					break;

   189

				case WKC_BACKSPACE:

   190

					if (_iconsole_cmdpos != 0) _iconsole_cmdpos--;

   191

					_iconsole_cmdline[_iconsole_cmdpos] = 0;

   192

					SetWindowDirty(w);

   193

					_iconsole_cmdbufferpos = 19;

   194

					break;

   195

				default:

   199

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

   201

							_iconsole_cmdpos++;

   202

						SetWindowDirty(w);

   204

					}

   205

					else

   206

						e->keypress.cont = true;

   207

			}

   208

			break;

   209

		}

   210

	}

   211

}

   212

   213

void IConsoleInit(void)

   214

{

   215

	uint i;

   216

	#if defined(WITH_REV)

   217

	extern char _openttd_revision[];

   218

	#endif

   219

	_iconsole_output_file = NULL;

   220

	_iconsole_color_default = 1;

   221

	_iconsole_color_error = 3;

   222

	_iconsole_color_warning = 13;

   223

	_iconsole_color_debug = 5;

   224

	_iconsole_color_commands = 2;

   227

	_iconsole_inited = true;

   228

	_iconsole_mode = ICONSOLE_CLOSED;

   229

	_iconsole_win = NULL;

   230

	_icursor_state = false;

   231

	_icursor_rate = 5;

   232

	_icursor_counter = 0;

   233

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

   234

		_iconsole_cmdbuffer[i] = NULL;

   236

		_iconsole_buffer[i] = NULL;

   237

		_iconsole_cbuffer[i] = 0;

   238

	}

   239

	IConsoleStdLibRegister();

   240

	#if defined(WITH_REV)

   241

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

   242

	#else

   243

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

   244

	#endif

   245

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

   246

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

   247

	IConsolePrint(12, "");

   248

	IConsoleClearCommand();

   249

	IConsoleCmdBufferAdd("");

   250

}

   251

   252

void IConsoleClear(void)

   253

{

   254

	uint i;

   256

		free(_iconsole_buffer[i]);

   257

}

   258

   259

void IConsoleFree(void)

   260

{

   261

	_iconsole_inited = false;

   262

	IConsoleClear();

   263

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

   264

}

   265

   266

void IConsoleResize(void)

   267

{

   268

	if (_iconsole_win != NULL) {

   269

		_iconsole_win->height = _screen.height / 3;

   270

		_iconsole_win->width = _screen.width;

   271

	}

   272

}

   273

   274

void IConsoleSwitch(void)

   275

{

   276

	switch (_iconsole_mode) {

   277

		case ICONSOLE_CLOSED:

   278

			_iconsole_win = AllocateWindowDesc(&_iconsole_window_desc);

   279

			_iconsole_win->height = _screen.height / 3;

   280

			_iconsole_win->width = _screen.width;

   281

			_iconsole_mode = ICONSOLE_OPENED;

   282

			break;

   283

		case ICONSOLE_OPENED:

   284

			DeleteWindowById(WC_CONSOLE, 0);

   285

			_iconsole_win = NULL;

   286

			_iconsole_mode = ICONSOLE_CLOSED;

   287

			break;

   288

	}

   289

	MarkWholeScreenDirty();

   290

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

   291

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

   292

}

   293

   294

void IConsoleClose(void)

   295

{

   296

	if (_iconsole_mode == ICONSOLE_OPENED) IConsoleSwitch();

   297

	_iconsole_mode = ICONSOLE_CLOSED;

   298

}

   299

   300

void IConsoleOpen(void)

   301

{

   302

	if (_iconsole_mode == ICONSOLE_CLOSED) IConsoleSwitch();

   304

}

   305

   306

void IConsoleCmdBufferAdd(const char* cmd)

   307

{

   308

	int i;

   309

	if (_iconsole_cmdbufferpos != 19) return;

   310

	free(_iconsole_cmdbuffer[18]);

   311

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

   312

	_iconsole_cmdbuffer[0] = strdup(cmd);

   313

}

   314

   315

void IConsoleCmdBufferNavigate(signed char direction)

   316

{

   317

	int i;

   318

	i = _iconsole_cmdbufferpos + direction;

   319

	if (i < 0) i = 19;

   320

	if (i > 19) i = 0;

   321

	if (direction > 0)

   322

		while (_iconsole_cmdbuffer[i] == NULL) {

   323

			++i;

   324

			if (i > 19) i = 0;

   325

		}

   326

	if (direction < 0)

   327

		while (_iconsole_cmdbuffer[i] == NULL) {

   328

			--i;

   329

			if (i < 0) i = 19;

   330

		}

   331

	_iconsole_cmdbufferpos = i;

   332

	IConsoleClearCommand();

   333

	memcpy(_iconsole_cmdline, _iconsole_cmdbuffer[i],

   334

		strlen(_iconsole_cmdbuffer[i]));

   335

	_iconsole_cmdpos = strlen(_iconsole_cmdbuffer[i]);

   336

}

   337

   338

void IConsolePrint(byte color_code, const char* string)

   339

{

   340

	char* _ex;

   341

	char* _new;

   342

	char _exc;

   343

	char _newc;

   344

	char* i;

   345

	int j;

   346

   347

	if (!_iconsole_inited) return;

   348

   349

	_newc = color_code;

   350

	_new = strdup(string);

   351

   352

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

   354

   356

		_ex = _iconsole_buffer[j];

   357

		_exc = _iconsole_cbuffer[j];

   358

		_iconsole_buffer[j] = _new;

   359

		_iconsole_cbuffer[j] = _newc;

   360

		_new = _ex;

   361

		_newc = _exc;

   362

	}

   363

	free(_ex);

   364

   365

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

   366

}

   367

   368

   369

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

   370

{

   371

	va_list va;

   372

	char buf[1024];

   373

	int len;

   374

   375

	va_start(va, s);

   376

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

   377

	va_end(va);

   378

   379

	IConsolePrint(color_code, buf);

   380

   381

	if (_iconsole_output_file != NULL) {

   382

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

   383

		fwrite(buf, len, 1, _iconsole_output_file);

   385

	}

   386

}

   387

   388

void IConsoleDebug(const char* string)

   389

{

   390

	if (_stdlib_developer > 1)

   391

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

   392

}

   393

   394

void IConsoleError(const char* string)

   395

{

   396

	if (_stdlib_developer > 0)

   397

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

   398

}

   399

   400

void IConsoleWarning(const char* string)

   401

{

   402

	if (_stdlib_developer > 0)

   403

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

   404

}

   405

   406

void IConsoleCmdRegister(const char* name, _iconsole_cmd_addr addr)

   407

{

   408

	char* _new;

   409

	_iconsole_cmd* item;

   410

	_iconsole_cmd* item_new;

   411

   412

	_new = strdup(name);

   413

   414

	item_new = malloc(sizeof(_iconsole_cmd));

   415

   416

	item_new->_next = NULL;

   417

	item_new->addr = addr;

   418

	item_new->name = _new;

   419

   420

	item_new->hook_access = NULL;

   421

	item_new->hook_after_exec = NULL;

   422

	item_new->hook_before_exec = NULL;

   423

   424

	item = _iconsole_cmds;

   425

	if (item == NULL) {

   426

		_iconsole_cmds = item_new;

   427

	} else {

   428

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

   429

		item->_next = item_new;

   430

	}

   431

}

   432

   433

_iconsole_cmd* IConsoleCmdGet(const char* name)

   434

{

   435

	_iconsole_cmd* item;

   436

   437

	item = _iconsole_cmds;

   438

	while (item != NULL) {

   439

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

   440

		item = item->_next;

   441

	}

   442

	return NULL;

   443

}

   444

   445

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

   446

{

   447

	_iconsole_var* item;

   448

	_iconsole_var* item_new;

   449

   450

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

   451

   452

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

   453

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

   454

   455

	item_new->_next = NULL;

   456

	switch (type) {

   457

		case ICONSOLE_VAR_BOOLEAN:

   458

			item_new->data.bool_ = addr;

   459

			break;

   460

		case ICONSOLE_VAR_BYTE:

   461

			item_new->data.byte_ = addr;

   462

			break;

   463

		case ICONSOLE_VAR_UINT16:

   464

			item_new->data.uint16_ = addr;

   465

			break;

   466

		case ICONSOLE_VAR_UINT32:

   467

			item_new->data.uint32_ = addr;

   468

			break;

   469

		case ICONSOLE_VAR_INT16:

   470

			item_new->data.int16_ = addr;

   471

			break;

   472

		case ICONSOLE_VAR_INT32:

   473

			item_new->data.int32_ = addr;

   474

			break;

   475

		case ICONSOLE_VAR_STRING:

   476

			item_new->data.string_ = addr;

   477

			break;

   478

		default:

   480

			break;

   481

	}

   482

	item_new->type = type;

   483

	item_new->_malloc = false;

   484