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

#include "network.h"

    14

    15

#ifdef WIN32

    16

#include <windows.h>

    17

#endif

    18

    19

#define ICON_BUFFER 79

    20

#define ICON_CMDBUF_SIZE 20

    21

#define ICON_CMDLN_SIZE 255

    22

#define ICON_LINE_HEIGHT 12

    23

#define ICON_RIGHT_BORDERWIDTH 10

    24

#define ICON_BOTTOM_BORDERWIDTH 12

    25

#define ICON_MAX_ALIAS_LINES 40

    26

    27

// ** main console ** //

    28

static bool _iconsole_inited;

    29

static char* _iconsole_buffer[ICON_BUFFER + 1];

    30

static uint16 _iconsole_cbuffer[ICON_BUFFER + 1];

    31

static char _iconsole_cmdline[ICON_CMDLN_SIZE];

    32

static byte _iconsole_cmdpos;

    33

static Window* _iconsole_win = NULL;

    34

static byte _iconsole_scroll;

    35

    36

// ** console cursor ** //

    37

static bool _icursor_state;

    38

static byte _icursor_rate;

    39

static byte _icursor_counter;

    40

    41

// ** stdlib ** //

    42

byte _stdlib_developer = 1;

    43

bool _stdlib_con_developer = false;

    44

FILE* _iconsole_output_file;

    45

    46

// ** main console cmd buffer

    47

static char* _iconsole_cmdbuffer[ICON_CMDBUF_SIZE];

    48

static byte _iconsole_cmdbufferpos;

    49

    50

// ** console window ** //

    51

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

    52

static const Widget _iconsole_window_widgets[] = {

    53

	{WIDGETS_END}

    54

};

    55

static const WindowDesc _iconsole_window_desc = {

    56

	0, 0, 2, 2,

    57

	WC_CONSOLE, 0,

    58

	WDF_STD_TOOLTIPS | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS,

    59

	_iconsole_window_widgets,

    60

	IConsoleWndProc,

    61

};

    62

    63

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

    64

/*  end of header  */

    65

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

    66

    67

static void IConsoleAppendClipboard(void)

    68

{

    69

#ifdef WIN32

    70

	if (IsClipboardFormatAvailable(CF_TEXT)) {

    71

		const char* data;

    72

		HGLOBAL cbuf;

    73

    74

		OpenClipboard(NULL);

    75

		cbuf = GetClipboardData(CF_TEXT);

    76

		data = GlobalLock(cbuf);

    77

    78

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

    79

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

    80

			_iconsole_cmdline[_iconsole_cmdpos++] = *data;

    81

    82

		GlobalUnlock(cbuf);

    83

		CloseClipboard();

    84

	}

    85

#endif

    86

}

    87

    88

static void IConsoleClearCommand(void)

    89

{

    90

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

    91

	_iconsole_cmdpos = 0;

    92

	SetWindowDirty(_iconsole_win);

    93

}

    94

    95

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

    96

{

    97

	// only do window events with the console

    98

	w = FindWindowById(WC_CONSOLE, 0);

    99

   100

	switch(e->event) {

   101

		case WE_PAINT:

   102

		{

   103

			int i = _iconsole_scroll;

   104

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

   105

			int delta = 0;

   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,

   109

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

   110

				i--;

   111

			}

   112

			delta = w->width - 10 - GetStringWidth(_iconsole_cmdline) - ICON_RIGHT_BORDERWIDTH;

   113

			if (delta > 0) {

   114

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

   115

				delta = 0;

   116

			}

   117

   118

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

   119

			break;

   120

		}

   121

		case WE_TICK:

   122

			_icursor_counter++;

   123

			if (_icursor_counter > _icursor_rate) {

   124

				int posx;

   125

				int posy;

   126

				int delta;

   127

   128

				_icursor_state = !_icursor_state;

   129

   130

				_cur_dpi = &_screen;

   131

				delta = w->width - 10 - GetStringWidth(_iconsole_cmdline) - ICON_RIGHT_BORDERWIDTH;

   132

				if (delta > 0)

   133

					delta = 0;

   134

				posx = 10 + GetStringWidth(_iconsole_cmdline) + delta;

   135

				posy = w->height - 3;

   136

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

   137

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

   138

				_icursor_counter = 0;

   139

			}

   140

			break;

   141

		case WE_DESTROY:

   142

			_iconsole_win = NULL;

   143

			_iconsole_mode = ICONSOLE_CLOSED;

   144

			break;

   145

		case WE_KEYPRESS:

   146

		{

   147

			e->keypress.cont = false;

   148

			switch (e->keypress.keycode) {

   149

				case WKC_CTRL | 'V':

   150

					IConsoleAppendClipboard();

   151

					SetWindowDirty(w);

   152

					break;

   153

				case WKC_UP:

   154

					IConsoleCmdBufferNavigate(+1);

   155

					SetWindowDirty(w);

   156

					break;

   157

				case WKC_DOWN:

   158

					IConsoleCmdBufferNavigate(-1);

   159

					SetWindowDirty(w);

   160

					break;

   161

				case WKC_SHIFT | WKC_PAGEUP:

   162

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

   163

						_iconsole_scroll = 0;

   164

					else

   165

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

   166

					SetWindowDirty(w);

   167

					break;

   168

				case WKC_SHIFT | WKC_PAGEDOWN:

   169

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

   170

						_iconsole_scroll = ICON_BUFFER;

   171

					else

   172

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

   173

					SetWindowDirty(w);

   174

					break;

   175

				case WKC_SHIFT | WKC_UP:

   176

					if (_iconsole_scroll <= 0)

   177

						_iconsole_scroll = 0;

   178

					else

   179

						--_iconsole_scroll;

   180

					SetWindowDirty(w);

   181

					break;

   182

				case WKC_SHIFT | WKC_DOWN:

   183

					if (_iconsole_scroll >= ICON_BUFFER)

   184

						_iconsole_scroll = ICON_BUFFER;

   185

					else

   186

						++_iconsole_scroll;

   187

					SetWindowDirty(w);

   188

					break;

   189

				case WKC_BACKQUOTE:

   190

					IConsoleSwitch();

   191

					break;

   192

				case WKC_RETURN:

   193

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

   194

					_iconsole_cmdbufferpos = 19;

   195

					IConsoleCmdBufferAdd(_iconsole_cmdline);

   199

					IConsoleClearCommand();

   200

					break;

   201

				case WKC_CTRL | WKC_RETURN:

   202

					if (_iconsole_mode == ICONSOLE_FULL) {

   203

						_iconsole_mode = ICONSOLE_OPENED;

   204

					} else {

   205

						_iconsole_mode = ICONSOLE_FULL;

   206

					}

   207

					IConsoleResize();

   208

					MarkWholeScreenDirty();

   209

					break;

   210

				case WKC_BACKSPACE:

   211

					if (_iconsole_cmdpos != 0) _iconsole_cmdpos--;

   212

					_iconsole_cmdline[_iconsole_cmdpos] = 0;

   213

					SetWindowDirty(w);

   214

					_iconsole_cmdbufferpos = 19;

   215

					break;

   216

				default:

   217

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

   218

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

   219

						_iconsole_scroll = ICON_BUFFER;

   220

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

   221

						if (_iconsole_cmdpos != lengthof(_iconsole_cmdline))

   222

							_iconsole_cmdpos++;

   223

						SetWindowDirty(w);

   224

						_iconsole_cmdbufferpos = ICON_CMDBUF_SIZE - 1;

   225

					}

   226

					else

   227

						e->keypress.cont = true;

   228

			}

   229

			break;

   230

		}

   231

	}

   232

}

   233

   234

extern const char _openttd_revision[];

   235

   236

void IConsoleInit(void)

   237

{

   238

	uint i;

   239

	_iconsole_output_file = NULL;

   240

	_iconsole_color_default = 1;

   241

	_iconsole_color_error = 3;

   242

	_iconsole_color_warning = 13;

   243

	_iconsole_color_debug = 5;

   244

	_iconsole_color_commands = 2;

   245

	_iconsole_scroll = ICON_BUFFER;

   246

	_iconsole_cmdbufferpos = ICON_CMDBUF_SIZE - 1;

   247

	_iconsole_inited = true;

   248

	_iconsole_mode = ICONSOLE_CLOSED;

   249

	_iconsole_win = NULL;

   250

	_icursor_state = false;

   251

	_icursor_rate = 5;

   252

	_icursor_counter = 0;

   253

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

   254

		_iconsole_cmdbuffer[i] = NULL;

   255

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

   256

		_iconsole_buffer[i] = NULL;

   257

		_iconsole_cbuffer[i] = 0;

   258

	}

   259

	IConsoleStdLibRegister();

   260

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

   261

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

   262

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

   263

	IConsolePrint(12, "");

   264

	IConsoleClearCommand();

   265

	IConsoleCmdBufferAdd("");

   266

}

   267

   268

void IConsoleClear(void)

   269

{

   270

	uint i;

   271

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

   272

		free(_iconsole_buffer[i]);

   273

}

   274

   275

void IConsoleFree(void)

   276

{

   277

	_iconsole_inited = false;

   278

	IConsoleClear();

   279

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

   280

}

   281

   282

void IConsoleResize(void)

   283

{

   284

	switch (_iconsole_mode) {

   285

		case ICONSOLE_OPENED:

   286

			_iconsole_win->height = _screen.height / 3;

   287

			_iconsole_win->width = _screen.width;

   288

			break;

   289

		case ICONSOLE_FULL:

   290

			_iconsole_win->height = _screen.height - ICON_BOTTOM_BORDERWIDTH;

   291

			_iconsole_win->width = _screen.width;

   292

			break;

   293

		default:

   294

			break;

   295

	}

   296

}

   297

   298

void IConsoleSwitch(void)

   299

{

   300

	switch (_iconsole_mode) {

   301

		case ICONSOLE_CLOSED:

   302

			_iconsole_win = AllocateWindowDesc(&_iconsole_window_desc);

   303

			_iconsole_win->height = _screen.height / 3;

   304

			_iconsole_win->width = _screen.width;

   305

			_iconsole_mode = ICONSOLE_OPENED;

   306

			break;

   307

		case ICONSOLE_OPENED:

   308

			DeleteWindowById(WC_CONSOLE, 0);

   309

			_iconsole_win = NULL;

   310

			_iconsole_mode = ICONSOLE_CLOSED;

   311

			break;

   312

		case ICONSOLE_FULL:

   313

			DeleteWindowById(WC_CONSOLE, 0);

   314

			_iconsole_win = NULL;

   315

			_iconsole_mode = ICONSOLE_CLOSED;

   316

			break;

   317

	}

   318

}

   319

   320

void IConsoleClose(void)

   321

{

   322

	if (_iconsole_mode == ICONSOLE_OPENED) IConsoleSwitch();

   323

}

   324

   325

void IConsoleOpen(void)

   326

{

   327

	if (_iconsole_mode == ICONSOLE_CLOSED) IConsoleSwitch();

   328

}

   329

   330

void IConsoleCmdBufferAdd(const char* cmd)

   331

{

   332

	int i;

   333

	if (_iconsole_cmdbufferpos != 19) return;

   334

	free(_iconsole_cmdbuffer[18]);

   335

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

   336

	_iconsole_cmdbuffer[0] = strdup(cmd);

   337

}

   338

   339

void IConsoleCmdBufferNavigate(signed char direction)

   340

{

   341

	int i;

   342

	i = _iconsole_cmdbufferpos + direction;

   343

	if (i < 0) i = 19;

   344

	if (i > 19) i = 0;

   345

	if (direction > 0)

   346

		while (_iconsole_cmdbuffer[i] == NULL) {

   347

			++i;

   348

			if (i > 19) i = 0;

   349

		}

   350

	if (direction < 0)

   351

		while (_iconsole_cmdbuffer[i] == NULL) {

   352

			--i;

   353

			if (i < 0) i = 19;

   354

		}

   355

	_iconsole_cmdbufferpos = i;

   356

	IConsoleClearCommand();

   357

	memcpy(_iconsole_cmdline, _iconsole_cmdbuffer[i],

   358

		strlen(_iconsole_cmdbuffer[i]));

   359

	_iconsole_cmdpos = strlen(_iconsole_cmdbuffer[i]);

   360

}

   361

   362

void IConsolePrint(uint16 color_code, const char* string)

   363

{

   364

	char* _ex;

   365

	char* _new;

   366

	uint16 _exc;

   367

	uint16 _newc;

   368

	char* i;

   369

	int j;

   370

   371

	if (_network_dedicated) {

   372

		printf("%s\n", string);

   373

		return;

   374

	}

   375

   376

	if (!_iconsole_inited) return;

   377

   378

	_newc = color_code;

   379

	_new = strdup(string);

   380

   381

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

   382

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

   383

   384

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

   385

		_ex = _iconsole_buffer[j];

   386

		_exc = _iconsole_cbuffer[j];

   387

		_iconsole_buffer[j] = _new;

   388

		_iconsole_cbuffer[j] = _newc;

   389

		_new = _ex;

   390

		_newc = _exc;

   391

	}

   392

	free(_ex);

   393

   394

	if (_iconsole_output_file != NULL) {

   395

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

   396

		fwrite(string, strlen(string), 1, _iconsole_output_file);

   397

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

   398

	}

   399

   400

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

   401

}

   402

   403

   404

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

   405

{

   406

	va_list va;

   407

	char buf[1024];

   408

	int len;

   409

   410

	va_start(va, s);

   411

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

   412

	va_end(va);

   413

   414

	IConsolePrint(color_code, buf);

   415

}

   416

   417

void IConsoleDebug(const char* string)

   418

{

   419

	if (_stdlib_developer > 1)

   420

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

   421

}

   422

   423

void IConsoleError(const char* string)

   424

{

   425

	if (_stdlib_developer > 0)

   426

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

   427

}

   428

   429

void IConsoleWarning(const char* string)

   430

{

   431

	if (_stdlib_developer > 0)

   432

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

   433

}

   434

   435

void IConsoleCmdRegister(const char* name, _iconsole_cmd_addr addr)

   436

{

   437

	char* _new;

   438

	_iconsole_cmd* item;

   439

	_iconsole_cmd* item_new;

   440

	_iconsole_cmd* item_before;

   441

   442

	_new = strdup(name);

   443

   444

	item_new = malloc(sizeof(_iconsole_cmd));

   445

   446

	item_new->_next = NULL;

   447

	item_new->addr = addr;

   448

	item_new->name = _new;

   449

   450

	item_new->hook_access = NULL;

   451

	item_new->hook_after_exec = NULL;

   452

	item_new->hook_before_exec = NULL;

   453

   454

	item_before = NULL;

   455

	item = _iconsole_cmds;

   456

   457

	if (item == NULL) {

   458

		_iconsole_cmds = item_new;

   459

	} else {

   460

		while ((item->_next != NULL) && (strcmp(item->name,item_new->name)<=0)) {

   461

			item_before = item;

   462

			item = item->_next;

   463

			}

   464

// insertion sort

   465

		if (item_before==NULL) {

   466

			if (strcmp(item->name,item_new->name)<=0) {

   467

				// appending

   468

				item ->_next = item_new;

   469

			} else {

   470

				// inserting as startitem

   471

				_iconsole_cmds = item_new;

   472

				item_new ->_next = item;

   473

			}

   474

		} else {

   475

			if (strcmp(item->name,item_new->name)<=0) {

   476

				// appending

   477

				item ->_next = item_new;

   478

			} else {

   479

				// inserting

   480

				item_new ->_next = item_before->_next;

   481

				item_before ->_next = item_new;

   482

			}

   483

		}

   484

// insertion sort end