1

/* $Id$ */

     2

     3

/** @file newgrf_gui.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "functions.h"

     8

#include "variables.h"

     9

#include "gfx.h"

    10

#include "gui.h"

    11

#include "window.h"

    12

#include "table/strings.h"

    13

#include "table/sprites.h"

    14

#include "newgrf.h"

    15

#include "newgrf_config.h"

    16

#include "strings.h"

    17

#include "helpers.hpp"

    18

    19

/** Parse an integerlist string and set each found value

    20

 * @param p the string to be parsed. Each element in the list is seperated by a

    21

 * comma or a space character

    22

 * @param items pointer to the integerlist-array that will be filled with values

    23

 * @param maxitems the maximum number of elements the integerlist-array has

    24

 * @return returns the number of items found, or -1 on an error */

    25

static int parse_intlist(const char *p, int *items, int maxitems)

    26

{

    27

	int n = 0, v;

    28

	char *end;

    29

    30

	for (;;) {

    31

		v = strtol(p, &end, 0);

    32

		if (p == end || n == maxitems) return -1;

    33

		p = end;

    34

		items[n++] = v;

    35

		if (*p == '\0') break;

    36

		if (*p != ',' && *p != ' ') return -1;

    37

		p++;

    38

	}

    39

    40

	return n;

    41

}

    42

    43

    44

static void ShowNewGRFInfo(const GRFConfig *c, uint x, uint y, uint w, uint bottom, bool show_params)

    45

{

    46

	char buff[256];

    47

    48

	if (c->error != NULL) {

    49

		SetDParamStr(0, c->filename);

    50

		SetDParamStr(1, c->error->data);

    51

		for (uint i = 0; i < c->error->num_params; i++) {

    52

			uint32 param = 0;

    53

			byte param_number = c->error->param_number[i];

    54

    55

			if (param_number < c->num_params) param = c->param[param_number];

    56

    57

			SetDParam(2 + i, param);

    58

		}

    59

    60

		char message[512];

    61

		GetString(message, c->error->custom_message != NULL ? BindCString(c->error->custom_message) : c->error->message, lastof(message));

    62

    63

		SetDParamStr(0, message);

    64

		y += DrawStringMultiLine(x, y, c->error->severity, w, bottom - y);

    65

	}

    66

    67

	/* Draw filename or not if it is not known (GRF sent over internet) */

    68

	if (c->filename != NULL) {

    69

		SetDParamStr(0, c->filename);

    70

		y += DrawStringMultiLine(x, y, STR_NEWGRF_FILENAME, w, bottom - y);

    71

	}

    72

    73

	/* Prepare and draw GRF ID */

    74

	snprintf(buff, lengthof(buff), "%08X", BSWAP32(c->grfid));

    75

	SetDParamStr(0, buff);

    76

	y += DrawStringMultiLine(x, y, STR_NEWGRF_GRF_ID, w, bottom - y);

    77

    78

	/* Prepare and draw MD5 sum */

    79

	md5sumToString(buff, lastof(buff), c->md5sum);

    80

	SetDParamStr(0, buff);

    81

	y += DrawStringMultiLine(x, y, STR_NEWGRF_MD5SUM, w, bottom - y);

    82

    83

	/* Show GRF parameter list */

    84

	if (show_params) {

    85

		if (c->num_params > 0) {

    86

			GRFBuildParamList(buff, c, lastof(buff));

    87

			SetDParamStr(0, buff);

    88

		} else {

    89

			SetDParam(0, STR_01A9_NONE);

    90

		}

    91

		y += DrawStringMultiLine(x, y, STR_NEWGRF_PARAMETER, w, bottom - y);

    92

	}

    93

    94

	/* Show flags */

    95

	if (c->status == GCS_NOT_FOUND)        y += DrawStringMultiLine(x, y, STR_NEWGRF_NOT_FOUND, w, bottom - y);

    96

	if (c->status == GCS_DISABLED)         y += DrawStringMultiLine(x, y, STR_NEWGRF_DISABLED, w, bottom - y);

    97

	if (HASBIT(c->flags, GCF_COMPATIBLE)) y += DrawStringMultiLine(x, y, STR_NEWGRF_COMPATIBLE_LOADED, w, bottom - y);

    98

    99

	/* Draw GRF info if it exists */

   100

	if (c->info != NULL && !StrEmpty(c->info)) {

   101

		SetDParamStr(0, c->info);

   102

		y += DrawStringMultiLine(x, y, STR_02BD, w, bottom - y);

   103

	} else {

   104

		y += DrawStringMultiLine(x, y, STR_NEWGRF_NO_INFO, w, bottom - y);

   105

	}

   106

}

   107

   108

   109

/* Dialogue for adding NewGRF files to the selection */

   110

struct newgrf_add_d {

   111

	GRFConfig **list;

   112

	const GRFConfig *sel;

   113

};

   114

   115

   116

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

   117

{

   118

	switch (e->event) {

   119

		case WE_PAINT: {

   120

			const GRFConfig *c;

   121

			int y;

   122

			int n = 0;

   123

   124

			/* Count the number of GRFs */

   125

			for (c = _all_grfs; c != NULL; c = c->next) n++;

   126

   127

			w->vscroll.cap = (w->widget[3].bottom - w->widget[3].top) / 10;

   128

			SetVScrollCount(w, n);

   129

   130

			SetWindowWidgetDisabledState(w, 6, WP(w, newgrf_add_d).sel == NULL || WP(w, newgrf_add_d).sel->IsOpenTTDBaseGRF());

   131

			DrawWindowWidgets(w);

   132

   133

			GfxFillRect(w->widget[3].left + 1, w->widget[3].top + 1, w->widget[3].right, w->widget[3].bottom, 0xD7);

   134

   135

			n = 0;

   136

			y = w->widget[3].top + 1;

   137

   138

			for (c = _all_grfs; c != NULL; c = c->next) {

   139

				if (n >= w->vscroll.pos && n < w->vscroll.pos + w->vscroll.cap) {

   140

					bool h = c == WP(w, newgrf_add_d).sel;

   141

					const char *text = (c->name != NULL && !StrEmpty(c->name)) ? c->name : c->filename;

   142

   143

					/* Draw selection background */

   144

					if (h) GfxFillRect(3, y, w->width - 15, y + 9, 156);

   145

					DoDrawStringTruncated(text, 4, y, h ? TC_WHITE : TC_ORANGE, w->width - 18);

   146

					y += 10;

   147

				}

   148

				n++;

   149

			}

   150

   151

			if (WP(w, newgrf_add_d).sel != NULL) {

   152

				const Widget *wi = &w->widget[5];

   153

				ShowNewGRFInfo(WP(w, newgrf_add_d).sel, wi->left + 2, wi->top + 2, wi->right - wi->left - 2, wi->bottom, false);

   154

			}

   155

			break;

   156

		}

   157

   158

		case WE_DOUBLE_CLICK:

   159

			if (e->we.click.widget != 3) break;

   160

			e->we.click.widget = 6;

   161

			/* Fall through */

   162

   163

		case WE_CLICK:

   164

			switch (e->we.click.widget) {

   165

				case 3: {

   166

					/* Get row... */

   167

					const GRFConfig *c;

   168

					uint i = (e->we.click.pt.y - w->widget[3].top) / 10 + w->vscroll.pos;

   169

   170

					for (c = _all_grfs; c != NULL && i > 0; c = c->next, i--);

   171

					WP(w, newgrf_add_d).sel = c;

   172

					SetWindowDirty(w);

   173

					break;

   174

				}

   175

   176

				case 6: // Add selection to list

   177

					if (WP(w, newgrf_add_d).sel != NULL) {

   178

						const GRFConfig *src = WP(w, newgrf_add_d).sel;

   179

						GRFConfig **list;

   180

   181

						/* Find last entry in the list, checking for duplicate grfid on the way */

   182

						for (list = WP(w, newgrf_add_d).list; *list != NULL; list = &(*list)->next) {

   183

							if ((*list)->grfid == src->grfid) {

   184

								ShowErrorMessage(INVALID_STRING_ID, STR_NEWGRF_DUPLICATE_GRFID, 0, 0);

   185

								return;

   186

							}

   187

						}

   188

   189

						/* Copy GRF details from scanned list */

   190

						GRFConfig *c = CallocT<GRFConfig>(1);

   191

						*c = *src;

   192

						c->filename = strdup(src->filename);

   193

						if (src->name      != NULL) c->name      = strdup(src->name);

   194

						if (src->info      != NULL) c->info      = strdup(src->info);

   195

						c->next = NULL;

   196

   197

						/* Append GRF config to configuration list */

   198

						*list = c;

   199

   200

						DeleteWindowByClass(WC_SAVELOAD);

   201

						InvalidateWindowData(WC_GAME_OPTIONS, 0);

   202

					}

   203

					break;

   204

   205

				case 7: // Rescan list

   206

					WP(w, newgrf_add_d).sel = NULL;

   207

					ScanNewGRFFiles();

   208

					SetWindowDirty(w);

   209

					break;

   210

			}

   211

			break;

   212

	}

   213

}

   214

   215

   216

static const Widget _newgrf_add_dlg_widgets[] = {

   217

{   WWT_CLOSEBOX,    RESIZE_NONE, 14,   0,  10,   0,  13, STR_00C5,                STR_018B_CLOSE_WINDOW },

   218

{    WWT_CAPTION,   RESIZE_RIGHT, 14,  11, 306,   0,  13, STR_NEWGRF_ADD_CAPTION,  STR_018C_WINDOW_TITLE_DRAG_THIS },

   219

   220

/* List of files */

   221

{      WWT_PANEL,      RESIZE_RB, 14,   0, 294,  14, 121, 0x0,                     STR_NULL },

   222

{      WWT_INSET,      RESIZE_RB, 14,   2, 292,  16, 119, 0x0,                     STR_NULL },

   223

{  WWT_SCROLLBAR,     RESIZE_LRB, 14, 295, 306,  14, 121, 0x0,                     STR_NULL },

   224

   225

/* NewGRF file info */

   226

{      WWT_PANEL,     RESIZE_RTB, 14,   0, 306, 122, 224, 0x0,                     STR_NULL },

   227

   228

{ WWT_PUSHTXTBTN,     RESIZE_RTB, 14,   0, 146, 225, 236, STR_NEWGRF_ADD_FILE,     STR_NEWGRF_ADD_FILE_TIP },

   229

{ WWT_PUSHTXTBTN,    RESIZE_LRTB, 14, 147, 294, 225, 236, STR_NEWGRF_RESCAN_FILES, STR_NEWGRF_RESCAN_FILES_TIP },

   230

{  WWT_RESIZEBOX,    RESIZE_LRTB, 14, 295, 306, 225, 236, 0x0,                     STR_RESIZE_BUTTON },

   231

{   WIDGETS_END },

   232

};

   233

   234

   235

static const WindowDesc _newgrf_add_dlg_desc = {

   236

	WDP_CENTER, WDP_CENTER, 307, 237, 307, 337,

   237

	WC_SAVELOAD, WC_NONE,

   238

	WDF_STD_TOOLTIPS | WDF_DEF_WIDGET | WDF_STD_BTN | WDF_UNCLICK_BUTTONS | WDF_RESIZABLE,

   239

	_newgrf_add_dlg_widgets,

   240

	NewGRFAddDlgWndProc,

   241

};

   242

   243

   244

/* 'NewGRF Settings' dialogue */

   245

struct newgrf_d {

   246

	GRFConfig **orig_list; ///< grf list the window is shown with

   247

	GRFConfig **list;      ///< temporary grf list to which changes are made

   248

	GRFConfig *sel;        ///< selected grf item

   249

	bool editable;         ///< is the window editable

   250

	bool show_params;      ///< are the grf-parameters shown in the info-panel

   251

	bool execute;          ///< on pressing 'apply changes' are grf changes applied immediately, or only list is updated

   252

};

   253

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(newgrf_d));

   254

   255

   256

enum ShowNewGRFStateWidgets {

   257

	SNGRFS_ADD = 3,

   258

	SNGRFS_REMOVE,

   259

	SNGRFS_MOVE_UP,

   260

	SNGRFS_MOVE_DOWN,

   261

	SNGRFS_FILE_LIST = 7,

   262

	SNGRFS_NEWGRF_INFO = 9,

   263

	SNGRFS_SET_PARAMETERS,

   264

	SNGRFS_APPLY_CHANGES,

   265

};

   266

   267

   268

static void SetupNewGRFState(Window *w)

   269

{

   270

	bool disable_all = WP(w, newgrf_d).sel == NULL || !WP(w, newgrf_d).editable;

   271

   272

	SetWindowWidgetDisabledState(w, 3, !WP(w, newgrf_d).editable);

   273

	SetWindowWidgetsDisabledState(w, disable_all,

   274

		SNGRFS_REMOVE,

   275

		SNGRFS_MOVE_UP,

   276

		SNGRFS_MOVE_DOWN,

   277

		WIDGET_LIST_END

   278

	);

   279

	SetWindowWidgetDisabledState(w, SNGRFS_SET_PARAMETERS, !WP(w, newgrf_d).show_params || disable_all);

   280

   281

	if (!disable_all) {

   282

		/* All widgets are now enabled, so disable widgets we can't use */

   283

		if (WP(w, newgrf_d).sel == *WP(w, newgrf_d).list) DisableWindowWidget(w, SNGRFS_MOVE_UP);

   284

		if (WP(w, newgrf_d).sel->next == NULL) DisableWindowWidget(w, SNGRFS_MOVE_DOWN);

   285

		if (WP(w, newgrf_d).sel->IsOpenTTDBaseGRF()) DisableWindowWidget(w, SNGRFS_REMOVE);

   286

	}

   287

}

   288

   289

   290

static void SetupNewGRFWindow(Window *w)

   291

{

   292

	const GRFConfig *c;

   293

	int i;

   294

   295

	for (c = *WP(w, newgrf_d).list, i = 0; c != NULL; c = c->next, i++);

   296

   297

	w->vscroll.cap = (w->widget[SNGRFS_FILE_LIST].bottom - w->widget[SNGRFS_FILE_LIST].top) / 14 + 1;

   298

	SetVScrollCount(w, i);

   299

	SetWindowWidgetDisabledState(w, SNGRFS_APPLY_CHANGES, !WP(w, newgrf_d).editable);

   300

}

   301

   302

   303

/** Callback function for the newgrf 'apply changes' confirmation window

   304

 * @param w Window which is calling this callback

   305

 * @param confirmed boolean value, true when yes was clicked, false otherwise

   306

 */

   307

static void NewGRFConfirmationCallback(Window *w, bool confirmed)

   308

{

   309

	if (confirmed) {

   310

		newgrf_d *nd = &WP(w, newgrf_d);

   311

		GRFConfig *c;

   312

		int i = 0;

   313

   314

		CopyGRFConfigList(nd->orig_list, *nd->list, false);

   315

		ReloadNewGRFData();

   316

   317

		/* Show new, updated list */

   318

		for (c = *nd->list; c != NULL && c != nd->sel; c = c->next, i++);

   319

		CopyGRFConfigList(nd->list, *nd->orig_list, false);

   320

		for (c = *nd->list; c != NULL && i > 0; c = c->next, i--);

   321

		nd->sel = c;

   322

   323

		SetWindowDirty(w);

   324

	}

   325

}

   326

   327

   328

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

   329

{

   330

	switch (e->event) {

   331

		case WE_PAINT: {

   332

			const GRFConfig *c;

   333

			int i, y;

   334

   335

			SetupNewGRFState(w);

   336

   337

			DrawWindowWidgets(w);

   338

   339

			/* Draw NewGRF list */

   340

			y = w->widget[SNGRFS_FILE_LIST].top;

   341

			for (c = *WP(w, newgrf_d).list, i = 0; c != NULL; c = c->next, i++) {

   342

				if (i >= w->vscroll.pos && i < w->vscroll.pos + w->vscroll.cap) {

   343

					const char *text = (c->name != NULL && !StrEmpty(c->name)) ? c->name : c->filename;

   344

					SpriteID pal;

   345

					byte txtoffset;

   346

   347

					/* Pick a colour */

   348

					switch (c->status) {

   349

						case GCS_NOT_FOUND:

   350

						case GCS_DISABLED:

   351

							pal = PALETTE_TO_RED;

   352

							break;

   353

						case GCS_ACTIVATED:

   354

							pal = PALETTE_TO_GREEN;

   355

							break;

   356

						default:

   357

							pal = PALETTE_TO_BLUE;

   358

							break;

   359

					}

   360

   361

					/* Do not show a "not-failure" colour when it actually failed to load */

   362

					if (pal != PALETTE_TO_RED) {

   363

						if (HASBIT(c->flags, GCF_STATIC)) {

   364

							pal = PALETTE_TO_GREY;

   365

						} else if (HASBIT(c->flags, GCF_COMPATIBLE)) {

   366

							pal = PALETTE_TO_ORANGE;

   367

						}

   368

					}

   369

   370

					DrawSprite(SPR_SQUARE, pal, 5, y + 2);

   371

					if (c->error != NULL) DrawSprite(SPR_WARNING_SIGN, 0, 20, y + 2);

   372

					txtoffset = c->error != NULL ? 35 : 25;

   373

					DoDrawStringTruncated(text, txtoffset, y + 3, WP(w, newgrf_d).sel == c ? TC_WHITE : TC_BLACK, w->width - txtoffset - 10);

   374

					y += 14;

   375

				}

   376

			}

   377

   378

			if (WP(w, newgrf_d).sel != NULL) {

   379

				/* Draw NewGRF file info */

   380

				const Widget *wi = &w->widget[SNGRFS_NEWGRF_INFO];

   381

				ShowNewGRFInfo(WP(w, newgrf_d).sel, wi->left + 2, wi->top + 2, wi->right - wi->left - 2, wi->bottom, WP(w, newgrf_d).show_params);

   382

			}

   383

   384

			break;

   385

		}

   386

   387

		case WE_INVALIDATE_DATA:

   388

			SetupNewGRFWindow(w);

   389

			break;

   390

   391

		case WE_CLICK:

   392

			switch (e->we.click.widget) {

   393

				case SNGRFS_ADD: { // Add GRF

   394

					GRFConfig **list = WP(w, newgrf_d).list;

   395

					Window *w;

   396

   397

					DeleteWindowByClass(WC_SAVELOAD);

   398

					w = AllocateWindowDesc(&_newgrf_add_dlg_desc);

   399

					w->resize.step_height = 10;

   400

   401

					WP(w, newgrf_add_d).list = list;

   402

					break;

   403

				}

   404

   405

				case SNGRFS_REMOVE: { // Remove GRF

   406

					GRFConfig **pc, *c, *newsel;

   407

   408

					/* Choose the next GRF file to be the selected file */

   409

					newsel = WP(w, newgrf_d).sel->next;

   410

   411

					for (pc = WP(w, newgrf_d).list; (c = *pc) != NULL; pc = &c->next) {

   412

						/* If the new selection is empty (i.e. we're deleting the last item

   413

						 * in the list, pick the file just before the selected file */

   414

						if (newsel == NULL && c->next == WP(w, newgrf_d).sel) newsel = c;

   415

   416

						if (c == WP(w, newgrf_d).sel) {

   417

							*pc = c->next;

   418

							free(c);

   419

							break;

   420

						}

   421

					}

   422

   423

					WP(w, newgrf_d).sel = newsel;

   424

					SetupNewGRFWindow(w);

   425

					SetWindowDirty(w);

   426

					break;

   427

				}

   428

   429

				case SNGRFS_MOVE_UP: { // Move GRF up

   430

					GRFConfig **pc, *c;

   431

					if (WP(w, newgrf_d).sel == NULL) break;

   432

   433

					for (pc = WP(w, newgrf_d).list; (c = *pc) != NULL; pc = &c->next) {

   434

						if (c->next == WP(w, newgrf_d).sel) {

   435

							c->next = WP(w, newgrf_d).sel->next;

   436

							WP(w, newgrf_d).sel->next = c;

   437

							*pc = WP(w, newgrf_d).sel;

   438

							break;

   439

						}

   440

					}

   441

					SetWindowDirty(w);

   442

					break;

   443

				}

   444

   445

				case SNGRFS_MOVE_DOWN: { // Move GRF down

   446

					GRFConfig **pc, *c;

   447

					if (WP(w, newgrf_d).sel == NULL) break;

   448

   449

					for (pc = WP(w, newgrf_d).list; (c = *pc) != NULL; pc = &c->next) {

   450

						if (c == WP(w, newgrf_d).sel) {

   451

							*pc = c->next;

   452

							c->next = c->next->next;

   453

							(*pc)->next = c;

   454

							break;

   455

						}

   456

					}

   457

					SetWindowDirty(w);

   458

					break;

   459

				}

   460

   461

				case SNGRFS_FILE_LIST: { // Select a GRF

   462

					GRFConfig *c;

   463

					uint i = (e->we.click.pt.y - w->widget[SNGRFS_FILE_LIST].top) / 14 + w->vscroll.pos;

   464

   465

					for (c = *WP(w, newgrf_d).list; c != NULL && i > 0; c = c->next, i--);

   466

					WP(w, newgrf_d).sel = c;

   467

   468

					SetWindowDirty(w);

   469

					break;

   470

				}

   471

   472

				case SNGRFS_APPLY_CHANGES: // Apply changes made to GRF list

   473

					if (WP(w, newgrf_d).execute) {

   474

						ShowQuery(

   475

							STR_POPUP_CAUTION_CAPTION,

   476

							STR_NEWGRF_CONFIRMATION_TEXT,

   477

							w,

   478

							NewGRFConfirmationCallback

   479

						);

   480

					} else {

   481

						CopyGRFConfigList(WP(w, newgrf_d).orig_list, *WP(w, newgrf_d).list, true);

   482

						ResetGRFConfig(false);

   483

						ReloadNewGRFData();

   484

					}

   485

					break;

   486

   487

				case SNGRFS_SET_PARAMETERS: { // Edit parameters

   488

					char buff[512];

   489

					if (WP(w, newgrf_d).sel == NULL) break;

   490

   491

					GRFBuildParamList(buff, WP(w, newgrf_d).sel, lastof(buff));

   492

					ShowQueryString(BindCString(buff), STR_NEWGRF_PARAMETER_QUERY, 63, 250, w, CS_ALPHANUMERAL);

   493

					break;

   494

				}

   495

			}

   496

			break;

   497

   498

		case WE_ON_EDIT_TEXT:

   499

			if (e->we.edittext.str != NULL) {

   500

				/* Parse our new "int list" */

   501

				GRFConfig *c = WP(w, newgrf_d).sel;

   502

				c->num_params = parse_intlist(e->we.edittext.str, (int*)c->param, lengthof(c->param));

   503

   504

				/* parse_intlist returns -1 on error */

   505