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 "helpers.hpp"

    15

    16

    17

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

    18

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

    19

 * comma or a space character

    20

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

    21

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

    22

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

    23

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

    24

{

    25

	int n = 0, v;

    26

	char *end;

    27

    28

	for (;;) {

    29

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

    30

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

    31

		p = end;

    32

		items[n++] = v;

    33

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

    34

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

    35

		p++;

    36

	}

    37

    38

	return n;

    39

}

    40

    41

    42

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

    43

{

    44

	char buff[256];

    45

    46

	if (c->error != NULL) {

    47

		SetDParamStr(0, c->error);

    48

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

    49

	}

    50

    51

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

    52

	if (c->filename != NULL) {

    53

		SetDParamStr(0, c->filename);

    54

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

    55

	}

    56

    57

	/* Prepare and draw GRF ID */

    58

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

    59

	SetDParamStr(0, buff);

    60

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

    61

    62

	/* Prepare and draw MD5 sum */

    63

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

    64

	SetDParamStr(0, buff);

    65

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

    66

    67

	/* Show GRF parameter list */

    68

	if (show_params) {

    69

		if (c->num_params > 0) {

    70

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

    71

			SetDParamStr(0, buff);

    72

		} else {

    73

			SetDParam(0, STR_01A9_NONE);

    74

		}

    75

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

    76

	}

    77

    78

	/* Show flags */

    79

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

    80

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

    81

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

    82

    83

	/* Draw GRF info if it exists */

    84

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

    85

		SetDParamStr(0, c->info);

    86

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

    87

	} else {

    88

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

    89

	}

    90

}

    91

    92

    93

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

    94

typedef struct newgrf_add_d {

    95

	GRFConfig **list;

    96

	const GRFConfig *sel;

    97

} newgrf_add_d;

    98

    99

   100

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

   101

{

   102

	switch (e->event) {

   103

		case WE_PAINT: {

   104

			const GRFConfig *c;

   105

			int y;

   106

			int n = 0;

   107

   108

			/* Count the number of GRFs */

   109

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

   110

   111

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

   112

			SetVScrollCount(w, n);

   113

   114

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

   115

			DrawWindowWidgets(w);

   116

   117

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

   118

   119

			n = 0;

   120

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

   121

   122

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

   123

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

   124

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

   125

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

   126

   127

					/* Draw selection background */

   128

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

   129

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

   130

					y += 10;

   131

				}

   132

				n++;

   133

			}

   134

   135

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

   136

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

   137

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

   138

			}

   139

			break;

   140

		}

   141

   142

		case WE_CLICK:

   143

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

   144

				case 3: {

   145

					// Get row...

   146

					const GRFConfig *c;

   147

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

   148

   149

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

   150

					WP(w, newgrf_add_d).sel = c;

   151

					SetWindowDirty(w);

   152

					break;

   153

				}

   154

   155

				case 6: /* Add selection to list */

   156

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

   157

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

   158

						GRFConfig **list;

   159

   160

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

   161

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

   162

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

   163

								ShowErrorMessage(INVALID_STRING_ID, STR_NEWGRF_DUPLICATE_GRFID, 0, 0);

   164

								return;

   165

							}

   166

						}

   167

   168

						/* Copy GRF details from scanned list */

   169

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

   170

						*c = *src;

   171

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

   172

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

   173

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

   174

						c->next = NULL;

   175

   176

						/* Append GRF config to configuration list */

   177

						*list = c;

   178

   179

						DeleteWindowByClass(WC_SAVELOAD);

   180

						InvalidateWindowData(WC_GAME_OPTIONS, 0);

   181

					}

   182

					break;

   183

   184

				case 7: /* Rescan list */

   185

					WP(w, newgrf_add_d).sel = NULL;

   186

					ScanNewGRFFiles();

   187

					SetWindowDirty(w);

   188

					break;

   189

			}

   190

			break;

   191

	}

   192

}

   193

   194

   195

static const Widget _newgrf_add_dlg_widgets[] = {

   196

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

   197

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

   198

   199

/* List of files */

   200

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

   201

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

   202

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

   203

   204

/* NewGRF file info */

   205

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

   206

   207

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

   208

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

   209

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

   210

{   WIDGETS_END },

   211

};

   212

   213

   214

static const WindowDesc _newgrf_add_dlg_desc = {

   215

	WDP_CENTER, WDP_CENTER, 307, 337,

   216

	WC_SAVELOAD, WC_NONE,

   217

	WDF_STD_TOOLTIPS | WDF_DEF_WIDGET | WDF_STD_BTN | WDF_UNCLICK_BUTTONS | WDF_RESIZABLE,

   218

	_newgrf_add_dlg_widgets,

   219

	NewGRFAddDlgWndProc,

   220

};

   221

   222

   223

/* 'NewGRF Settings' dialogue */

   224

typedef struct newgrf_d {

   225

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

   226

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

   227

	GRFConfig *sel;        ///< selected grf item

   228

	bool editable;         ///< is the window editable

   229

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

   230

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

   231

} newgrf_d;

   232

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(newgrf_d));

   233

   234

   235

enum ShowNewGRFStateWidgets {

   236

	SNGRFS_ADD = 3,

   237

	SNGRFS_REMOVE,

   238

	SNGRFS_MOVE_UP,

   239

	SNGRFS_MOVE_DOWN,

   240

	SNGRFS_FILE_LIST = 7,

   241

	SNGRFS_NEWGRF_INFO = 9,

   242

	SNGRFS_SET_PARAMETERS,

   243

	SNGRFS_APPLY_CHANGES,

   244

};

   245

   246

   247

static void SetupNewGRFState(Window *w)

   248

{

   249

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

   250

   251

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

   252

	SetWindowWidgetsDisabledState(w, disable_all,

   253

		SNGRFS_REMOVE,

   254

		SNGRFS_MOVE_UP,

   255

		SNGRFS_MOVE_DOWN,

   256

		WIDGET_LIST_END

   257

	);

   258

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

   259

   260

	if (!disable_all) {

   261

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

   262

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

   263

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

   264

	}

   265

}

   266

   267

   268

static void SetupNewGRFWindow(Window *w)

   269

{

   270

	const GRFConfig *c;

   271

	int i;

   272

   273

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

   274

   275

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

   276

	SetVScrollCount(w, i);

   277

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

   278

}

   279

   280

   281

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

   282

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

   283

static void NewGRFConfirmationCallback(Window *w, bool confirmed)

   284

{

   285

	if (confirmed) {

   286

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

   287

		GRFConfig *c;

   288

		int i = 0;

   289

   290

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

   291

		ReloadNewGRFData();

   292

   293

		/* Show new, updated list */

   294

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

   295

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

   296

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

   297

		nd->sel = c;

   298

   299

		SetWindowDirty(w);

   300

	}

   301

}

   302

   303

   304

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

   305

{

   306

	switch (e->event) {

   307

		case WE_PAINT: {

   308

			const GRFConfig *c;

   309

			int i, y;

   310

   311

			SetupNewGRFState(w);

   312

   313

			DrawWindowWidgets(w);

   314

   315

			/* Draw NewGRF list */

   316

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

   317

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

   318

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

   319

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

   320

					SpriteID pal;

   321

   322

					/* Pick a colour */

   323

					if (HASBIT(c->flags, GCF_NOT_FOUND) || HASBIT(c->flags, GCF_DISABLED)) {

   324

						pal = PALETTE_TO_RED;

   325

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

   326

						pal = PALETTE_TO_GREY;

   327

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

   328

						pal = PALETTE_TO_ORANGE;

   329

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

   330

						pal = PALETTE_TO_GREEN;

   331

					} else {

   332

						pal = PALETTE_TO_BLUE;

   333

					}

   334

   335

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

   336

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

   337

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

   338

					y += 14;

   339

				}

   340

			}

   341

   342

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

   343

				/* Draw NewGRF file info */

   344

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

   345

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

   346

			}

   347

   348

			break;

   349

		}

   350

   351

		case WE_INVALIDATE_DATA:

   352

			SetupNewGRFWindow(w);

   353

			break;

   354

   355

		case WE_CLICK:

   356

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

   357

				case SNGRFS_ADD: { /* Add GRF */

   358

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

   359

					Window *w;

   360

   361

					DeleteWindowByClass(WC_SAVELOAD);

   362

					w = AllocateWindowDesc(&_newgrf_add_dlg_desc);

   363

					w->resize.step_height = 10;

   364

   365

					WP(w, newgrf_add_d).list = list;

   366

					break;

   367

				}

   368

   369

				case SNGRFS_REMOVE: { /* Remove GRF */

   370

					GRFConfig **pc, *c, *newsel;

   371

   372

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

   373

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

   374

   375

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

   376

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

   377

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

   378

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

   379

   380

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

   381

							*pc = c->next;

   382

							free(c);

   383

							break;

   384

						}

   385

					}

   386

   387

					WP(w, newgrf_d).sel = newsel;

   388

					SetupNewGRFWindow(w);

   389

					SetWindowDirty(w);

   390

					break;

   391

				}

   392

   393

				case SNGRFS_MOVE_UP: { /* Move GRF up */

   394

					GRFConfig **pc, *c;

   395

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

   396

   397

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

   398

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

   399

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

   400

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

   401

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

   402

							break;

   403

						}

   404

					}

   405

					SetWindowDirty(w);

   406

					break;

   407

				}

   408

   409

				case SNGRFS_MOVE_DOWN: { /* Move GRF down */

   410

					GRFConfig **pc, *c;

   411

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

   412

   413

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

   414

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

   415

							*pc = c->next;

   416

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

   417

							(*pc)->next = c;

   418

							break;

   419

						}

   420

					}

   421

					SetWindowDirty(w);

   422

					break;

   423

				}

   424

   425

				case SNGRFS_FILE_LIST: { /* Select a GRF */

   426

					GRFConfig *c;

   427

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

   428

   429

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

   430

					WP(w, newgrf_d).sel = c;

   431

   432

					SetWindowDirty(w);

   433

					break;

   434

				}

   435

   436

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

   437

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

   438

						ShowQuery(

   439

							STR_POPUP_CAUTION_CAPTION,

   440

							STR_NEWGRF_CONFIRMATION_TEXT,

   441

							w,

   442

							NewGRFConfirmationCallback

   443

						);

   444

					} else {

   445

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

   446

					}

   447

					break;

   448

   449

				case SNGRFS_SET_PARAMETERS: { /* Edit parameters */

   450

					char buff[512];

   451

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

   452

   453

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

   454

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

   455

					break;

   456

				}

   457

			}

   458

			break;

   459

   460

		case WE_ON_EDIT_TEXT:

   461

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

   462

				/* Parse our new "int list" */

   463

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

   464

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

   465

   466

				/* parse_intlist returns -1 on error */

   467

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

   468

			}

   469

			SetWindowDirty(w);

   470

			break;

   471

   472

		case WE_DESTROY:

   473

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

   474

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

   475

			break;

   476

   477

		case WE_RESIZE:

   478

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

   479

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

   480

			break;

   481

	}

   482

}

   483

   484

   485

static const Widget _newgrf_widgets[] = {

   486

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

   487

{    WWT_CAPTION, RESIZE_RIGHT, 10,  11, 299,   0,  13, STR_NEWGRF_SETTINGS_CAPTION, STR_018C_WINDOW_TITLE_DRAG_THIS },

   488

   489

/* NewGRF file Add, Remove, Move up, Move down */

   490

{      WWT_PANEL, RESIZE_RIGHT, 10,   0, 299,  14,  29, STR_NULL,                    STR_NULL },

   491

{ WWT_PUSHTXTBTN,  RESIZE_NONE,  3,  10,  79,  16,  27, STR_NEWGRF_ADD,              STR_NEWGRF_ADD_TIP },

   492

{ WWT_PUSHTXTBTN,  RESIZE_NONE,  3,  80, 149,  16,  27, STR_NEWGRF_REMOVE,           STR_NEWGRF_REMOVE_TIP },

   493

{ WWT_PUSHTXTBTN,  RESIZE_NONE,  3, 150, 219,  16,  27, STR_NEWGRF_MOVEUP,           STR_NEWGRF_MOVEUP_TIP },

   494

{ WWT_PUSHTXTBTN,  RESIZE_NONE,  3, 220, 289,  16,  27, STR_NEWGRF_MOVEDOWN,         STR_NEWGRF_MOVEDOWN_TIP },

   495

   496

/* NewGRF file list */

   497

{     WWT_MATRIX,    RESIZE_RB, 10,   0, 287,  30,  99, 0x501,                       STR_NEWGRF_FILE_TIP },

   498

{  WWT_SCROLLBAR,   RESIZE_LRB, 10, 288, 299,  30,  99, 0x0,                         STR_0190_SCROLL_BAR_SCROLLS_LIST },

   499

   500

/* NewGRF file info */

   501

{      WWT_PANEL,   RESIZE_RTB, 10,   0, 299, 100, 212, STR_NULL,                    STR_NULL },

   502

   503

/* Edit parameter and apply changes button... */

   504

{ WWT_PUSHTXTBTN,    RESIZE_TB, 10,   0, 143, 213, 224, STR_NEWGRF_SET_PARAMETERS,   STR_NULL },

   505

{ WWT_PUSHTXTBTN,   RESIZE_RTB, 10, 144, 287, 213, 224, STR_NEWGRF_APPLY_CHANGES,    STR_NULL },

   506

   507

{  WWT_RESIZEBOX,  RESIZE_LRTB, 10, 288, 299, 213, 224, 0x0,                         STR_RESIZE_BUTTON },

   508

   509

{ WIDGETS_END },

   510

};

   511