1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "functions.h"

     6

#include "variables.h"

     7

#include "gfx.h"

     8

#include "gui.h"

     9

#include "window.h"

    10

#include "table/strings.h"

    11

#include "table/sprites.h"

    12

#include "newgrf.h"

    13

#include "newgrf_config.h"

    14

#include "strings.h"

    15

#include "helpers.hpp"

    16

    17

    18

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

    19

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

    20

 * comma or a space character

    21

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

    22

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

    23

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

    24

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

    25

{

    26

	int n = 0, v;

    27

	char *end;

    28

    29

	for (;;) {

    30

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

    31

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

    32

		p = end;

    33

		items[n++] = v;

    34

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

    35

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

    36

		p++;

    37

	}

    38

    39

	return n;

    40

}

    41

    42

    43

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

    44

{

    45

	char buff[256];

    46

    47

	if (c->error != NULL) {

    48

		SetDParamStr(0, c->filename);

    49

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

    50

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

    51

			uint32 param = 0;

    52

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

    53

    54

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

    55

    56

			SetDParam(2 + i, param);

    57

		}

    58

    59

		char message[512];

    60

		GetString(message, c->error->message, lastof(message));

    61

    62

		SetDParamStr(0, message);

    63

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

    64

	}

    65

    66

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

    67

	if (c->filename != NULL) {

    68

		SetDParamStr(0, c->filename);

    69

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

    70

	}

    71

    72

	/* Prepare and draw GRF ID */

    73

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

    74

	SetDParamStr(0, buff);

    75

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

    76

    77

	/* Prepare and draw MD5 sum */

    78

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

    79

	SetDParamStr(0, buff);

    80

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

    81

    82

	/* Show GRF parameter list */

    83

	if (show_params) {

    84

		if (c->num_params > 0) {

    85

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

    86

			SetDParamStr(0, buff);

    87

		} else {

    88

			SetDParam(0, STR_01A9_NONE);

    89

		}

    90

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

    91

	}

    92

    93

	/* Show flags */

    96

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

    97

    98

	/* Draw GRF info if it exists */

    99

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

   100

		SetDParamStr(0, c->info);

   101

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

   102

	} else {

   103

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

   104

	}

   105

}

   106

   107

   108

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

   110

	GRFConfig **list;

   111

	const GRFConfig *sel;

   113

   114

   115

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

   116

{

   117

	switch (e->event) {

   118

		case WE_PAINT: {

   119

			const GRFConfig *c;

   120

			int y;

   121

			int n = 0;

   122

   123

			/* Count the number of GRFs */

   124

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

   125

   126

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

   127

			SetVScrollCount(w, n);

   128

   129

			SetWindowWidgetDisabledState(w, 6, WP(w, newgrf_add_d).sel == NULL);

   130

			DrawWindowWidgets(w);

   131

   132

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

   133

   134

			n = 0;

   135

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

   136

   137

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

   138

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

   139

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

   140

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

   141

   142

					/* Draw selection background */

   143

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

   144

					DoDrawStringTruncated(text, 4, y, h ? 0xC : 0x6, w->width - 18);

   145

					y += 10;

   146

				}

   147

				n++;

   148

			}

   149

   150

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

   151

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

   152

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

   153

			}

   154

			break;

   155

		}

   156

   157

		case WE_CLICK:

   158

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

   159

				case 3: {

   160

					// Get row...

   161

					const GRFConfig *c;

   162

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

   163

   164

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

   165

					WP(w, newgrf_add_d).sel = c;

   166

					SetWindowDirty(w);

   167

					break;

   168

				}

   169

   170

				case 6: /* Add selection to list */

   171

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

   172

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

   173

						GRFConfig **list;

   174

   175

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

   176

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

   177

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

   178

								ShowErrorMessage(INVALID_STRING_ID, STR_NEWGRF_DUPLICATE_GRFID, 0, 0);

   179

								return;

   180

							}

   181

						}

   182

   183

						/* Copy GRF details from scanned list */

   184

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

   185

						*c = *src;

   186

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

   187

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

   188

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

   189

						c->next = NULL;

   190

   191

						/* Append GRF config to configuration list */

   192

						*list = c;

   193

   194

						DeleteWindowByClass(WC_SAVELOAD);

   195

						InvalidateWindowData(WC_GAME_OPTIONS, 0);

   196

					}

   197

					break;

   198

   199

				case 7: /* Rescan list */

   200

					WP(w, newgrf_add_d).sel = NULL;

   201

					ScanNewGRFFiles();

   202

					SetWindowDirty(w);

   203

					break;

   204

			}

   205

			break;

   206

	}

   207

}

   208

   209

   210

static const Widget _newgrf_add_dlg_widgets[] = {

   211

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

   212

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

   213

   214

/* List of files */

   215

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

   216

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

   217

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

   218

   219

/* NewGRF file info */

   220

{      WWT_PANEL,     RESIZE_RTB, 14,   0, 306, 222, 324, 0x0,                     STR_NULL },

   221

   222

{ WWT_PUSHTXTBTN,     RESIZE_RTB, 14,   0, 146, 325, 336, STR_NEWGRF_ADD_FILE,     STR_NEWGRF_ADD_FILE_TIP },

   223

{ WWT_PUSHTXTBTN,    RESIZE_LRTB, 14, 147, 294, 325, 336, STR_NEWGRF_RESCAN_FILES, STR_NEWGRF_RESCAN_FILES_TIP },

   224

{  WWT_RESIZEBOX,    RESIZE_LRTB, 14, 295, 306, 325, 336, 0x0,                     STR_RESIZE_BUTTON },

   225

{   WIDGETS_END },

   226

};

   227

   228

   229

static const WindowDesc _newgrf_add_dlg_desc = {

   230

	WDP_CENTER, WDP_CENTER, 307, 337,

   231

	WC_SAVELOAD, WC_NONE,

   232

	WDF_STD_TOOLTIPS | WDF_DEF_WIDGET | WDF_STD_BTN | WDF_UNCLICK_BUTTONS | WDF_RESIZABLE,

   233

	_newgrf_add_dlg_widgets,

   234

	NewGRFAddDlgWndProc,

   235

};

   236

   237

   238

/* 'NewGRF Settings' dialogue */

   240

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

   241

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

   242

	GRFConfig *sel;        ///< selected grf item

   243

	bool editable;         ///< is the window editable

   244

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

   245

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

   247

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(newgrf_d));

   248

   249

   250

enum ShowNewGRFStateWidgets {

   251

	SNGRFS_ADD = 3,

   252

	SNGRFS_REMOVE,

   253

	SNGRFS_MOVE_UP,

   254

	SNGRFS_MOVE_DOWN,

   255

	SNGRFS_FILE_LIST = 7,

   256

	SNGRFS_NEWGRF_INFO = 9,

   257

	SNGRFS_SET_PARAMETERS,

   258

	SNGRFS_APPLY_CHANGES,

   259

};

   260

   261

   262

static void SetupNewGRFState(Window *w)

   263

{

   264

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

   265

   266

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

   267

	SetWindowWidgetsDisabledState(w, disable_all,

   268

		SNGRFS_REMOVE,

   269

		SNGRFS_MOVE_UP,

   270

		SNGRFS_MOVE_DOWN,

   271

		WIDGET_LIST_END

   272

	);

   273

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

   274

   275

	if (!disable_all) {

   276

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

   277

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

   278

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

   279

	}

   280

}

   281

   282

   283

static void SetupNewGRFWindow(Window *w)

   284

{

   285

	const GRFConfig *c;

   286

	int i;

   287

   288

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

   289

   290

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

   291

	SetVScrollCount(w, i);

   292

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

   293

}

   294

   295

   296

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

   297

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

   298

static void NewGRFConfirmationCallback(Window *w, bool confirmed)

   299

{

   300

	if (confirmed) {

   301

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

   302

		GRFConfig *c;

   303

		int i = 0;

   304

   305

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

   306

		ReloadNewGRFData();

   307

   308

		/* Show new, updated list */

   309

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

   310

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

   311

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

   312

		nd->sel = c;

   313

   314

		SetWindowDirty(w);

   315

	}

   316

}

   317

   318

   319

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

   320

{

   321

	switch (e->event) {

   322

		case WE_PAINT: {

   323

			const GRFConfig *c;

   324

			int i, y;

   325

   326

			SetupNewGRFState(w);

   327

   328

			DrawWindowWidgets(w);

   329

   330

			/* Draw NewGRF list */

   331

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

   332

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

   333

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

   334

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

   335

					SpriteID pal;

   336

   337

					/* Pick a colour */

   352

						pal = PALETTE_TO_GREY;

   353

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

   354

						pal = PALETTE_TO_ORANGE;

   355

					}

   356

   357

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

   358

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

   359

					DoDrawString(text, c->error != NULL ? 35 : 25, y + 3, WP(w, newgrf_d).sel == c ? 0xC : 0x10);

   360

					y += 14;

   361

				}

   362

			}

   363

   364

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

   365

				/* Draw NewGRF file info */

   366

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

   367

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

   368

			}

   369

   370

			break;

   371

		}

   372

   373

		case WE_INVALIDATE_DATA:

   374

			SetupNewGRFWindow(w);

   375

			break;

   376

   377

		case WE_CLICK:

   378

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

   379

				case SNGRFS_ADD: { /* Add GRF */

   380

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

   381

					Window *w;

   382

   383

					DeleteWindowByClass(WC_SAVELOAD);

   384

					w = AllocateWindowDesc(&_newgrf_add_dlg_desc);

   385

					w->resize.step_height = 10;

   386

   387

					WP(w, newgrf_add_d).list = list;

   388

					break;

   389

				}

   390

   391

				case SNGRFS_REMOVE: { /* Remove GRF */

   392

					GRFConfig **pc, *c, *newsel;

   393

   394

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

   395

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

   396

   397

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

   398

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

   399

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

   400

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

   401

   402

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

   403

							*pc = c->next;

   404

							free(c);

   405

							break;

   406

						}

   407

					}

   408

   409

					WP(w, newgrf_d).sel = newsel;

   410

					SetupNewGRFWindow(w);

   411

					SetWindowDirty(w);

   412

					break;

   413

				}

   414

   415

				case SNGRFS_MOVE_UP: { /* Move GRF up */

   416

					GRFConfig **pc, *c;

   417

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

   418

   419

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

   420

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

   421

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

   422

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

   423

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

   424

							break;

   425

						}

   426

					}

   427

					SetWindowDirty(w);

   428

					break;

   429

				}

   430

   431

				case SNGRFS_MOVE_DOWN: { /* Move GRF down */

   432

					GRFConfig **pc, *c;

   433

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

   434

   435

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

   436

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

   437

							*pc = c->next;

   438

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

   439

							(*pc)->next = c;

   440

							break;

   441

						}

   442

					}

   443

					SetWindowDirty(w);

   444

					break;

   445

				}

   446

   447

				case SNGRFS_FILE_LIST: { /* Select a GRF */

   448

					GRFConfig *c;

   449

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

   450

   451

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

   452

					WP(w, newgrf_d).sel = c;

   453

   454

					SetWindowDirty(w);

   455

					break;

   456

				}

   457

   458

				case SNGRFS_APPLY_CHANGES: /* Apply changes made to GRF list */

   459

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

   460

						ShowQuery(

   461

							STR_POPUP_CAUTION_CAPTION,

   462

							STR_NEWGRF_CONFIRMATION_TEXT,

   463

							w,

   464

							NewGRFConfirmationCallback

   465

						);

   466

					} else {

   467

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

   468

					}

   469

					break;

   470

   471

				case SNGRFS_SET_PARAMETERS: { /* Edit parameters */

   472

					char buff[512];

   473

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

   474

   475

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

   476

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

   477

					break;

   478

				}

   479

			}

   480

			break;

   481

   482

		case WE_ON_EDIT_TEXT:

   483

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

   484

				/* Parse our new "int list" */

   485

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

   486

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

   487

   488

				/* parse_intlist returns -1 on error */

   489

				if (c->num_params == (byte)-1) c->num_params = 0;

   490

			}

   491

			SetWindowDirty(w);

   492

			break;

   493

   494

		case WE_DESTROY:

   495

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

   496

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

   497

			}

   498

			/* Remove the temporary copy of grf-list used in window */

   499

			ClearGRFConfigList(WP(w, newgrf_d).list);

   500

			break;

   501

   502

		case WE_RESIZE:

   503

			w->vscroll.cap += e->we.sizing.diff.y / 14;

   504

			w->widget[SNGRFS_FILE_LIST].data = (w->vscroll.cap << 8) + 1;

   505

			break;

   506

	}

   507

}

   508

   509