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 "strings.h"

    11

#include "table/strings.h"

    12

#include "table/sprites.h"

    13

#include "newgrf_config.h"

    14

    15

    16

/* Build a space separated list of parameters, and terminate */

    17

static char *BuildParamList(char *dst, const GRFConfig *c, const char *last)

    18

{

    19

	uint i;

    20

    21

	/* Return an empty string if there are no parameters */

    22

	if (c->num_params == 0) return strecpy(dst, "", last);

    23

    24

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

    25

		if (i > 0) dst = strecpy(dst, " ", last);

    26

		dst += snprintf(dst, last - dst, "%d", c->param[i]);

    27

	}

    28

	return dst;

    29

}

    30

    31

    32

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

    33

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

    34

 * comma or a space character

    35

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

    36

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

    37

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

    38

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

    39

{

    40

	int n = 0, v;

    41

	char *end;

    42

    43

	for (;;) {

    44

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

    45

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

    46

		p = end;

    47

		items[n++] = v;

    48

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

    49

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

    50

		p++;

    51

	}

    52

    53

	return n;

    54

}

    55

    56

    57

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

    58

{

    59

	char buff[512];

    60

	char *s;

    61

	uint i;

    62

    63

	/* Draw filename */

    64

	SetDParamStr(0, c->filename);

    65

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

    66

    67

	/* Prepare and draw GRF ID */

    68

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

    69

	SetDParamStr(0, buff);

    70

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

    71

    72

	/* Prepare and draw MD5 sum */

    73

	s = buff;

    74

	for (i = 0; i < lengthof(c->md5sum); i++) {

    75

		s += snprintf(s, lastof(buff) - s, "%02X", c->md5sum[i]);

    76

	}

    77

	SetDParamStr(0, buff);

    78

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

    79

    80

	/* Show GRF parameter list */

    81

	if (show_params) {

    82

		if (c->num_params > 0) {

    83

			BuildParamList(buff, c, lastof(buff));

    84

			SetDParamStr(0, buff);

    85

		} else {

    86

			SetDParam(0, STR_01A9_NONE);

    87

		}

    88

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

    89

	}

    90

    91

	/* Show flags */

    92

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

    93

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

    94

    95

	/* Draw GRF info if it exists */

    96

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

    97

		SetDParamStr(0, c->info);

    98

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

    99

	} else {

   100

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

   101

	}

   102

}

   103

   104

   105

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

   106

typedef struct newgrf_add_d {

   107

	GRFConfig **list;

   108

	const GRFConfig *sel;

   109

} newgrf_add_d;

   110

   111

   112

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

   113

{

   114

	switch (e->event) {

   115

		case WE_PAINT: {

   116

			const GRFConfig *c;

   117

			int y;

   118

			int n = 0;

   119

   120

			/* Count the number of GRFs */

   121

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

   122

   123

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

   124

			SetVScrollCount(w, n);

   125

   126

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

   127

			DrawWindowWidgets(w);

   128

   129

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

   130

   131

			n = 0;

   132

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

   133

   134

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

   135

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

   136

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

   137

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

   138

   139

					/* Draw selection background */

   140

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

   141

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

   142

					y += 10;

   143

				}

   144

				n++;

   145

			}

   146

   147

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

   148

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

   149

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

   150

			}

   151

			break;

   152

		}

   153

   154

		case WE_CLICK:

   155

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

   156

				case 3: {

   157

					// Get row...

   158

					const GRFConfig *c;

   159

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

   160

   161

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

   162

					WP(w, newgrf_add_d).sel = c;

   163

					SetWindowDirty(w);

   164

					break;

   165

				}

   166

   167

				case 6: /* Add selection to list */

   168

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

   169

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

   170

						GRFConfig **list, *c;

   171

   172

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

   173

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

   174

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

   175

								ShowErrorMessage(INVALID_STRING_ID, STR_NEWGRF_DUPLICATE_GRFID, 0, 0);

   176

								return;

   177

							}

   178

						}

   179

   180

						/* Copy GRF details from scanned list */

   181

						c = calloc(1, sizeof(*c));

   182

						*c = *src;

   183

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

   184

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

   185

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

   186

						c->next = NULL;

   187

   188

						/* Append GRF config to configuration list */

   189

						*list = c;

   190

   191

						DeleteWindowByClass(WC_SAVELOAD);

   192

						InvalidateWindowData(WC_GAME_OPTIONS, 0);

   193

					}

   194

					break;

   195

   196

				case 7: /* Rescan list */

   197

					WP(w, newgrf_add_d).sel = NULL;

   198

					ScanNewGRFFiles();

   199

					SetWindowDirty(w);

   200

					break;

   201

			}

   202

			break;

   203

	}

   204

}

   205

   206

   207

static const Widget _newgrf_add_dlg_widgets[] = {

   208

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

   209

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

   210

   211

/* List of files */

   212

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

   213

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

   214

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

   215

   216

/* NewGRF file info */

   217

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

   218

   219

{ WWT_PUSHTXTBTN,     RESIZE_RTB, 14,   0, 146, 312, 323, STR_NEWGRF_ADD_FILE,     STR_NEWGRF_ADD_FILE_TIP },

   220

{ WWT_PUSHTXTBTN,    RESIZE_LRTB, 14, 147, 294, 312, 323, STR_NEWGRF_RESCAN_FILES, STR_NEWGRF_RESCAN_FILES_TIP },

   221

{  WWT_RESIZEBOX,    RESIZE_LRTB, 14, 295, 306, 312, 323, 0x0,                     STR_RESIZE_BUTTON },

   222

{   WIDGETS_END },

   223

};

   224

   225

   226

static const WindowDesc _newgrf_add_dlg_desc = {

   227

	WDP_CENTER, WDP_CENTER, 307, 324,

   228

	WC_SAVELOAD, 0,

   229

	WDF_STD_TOOLTIPS | WDF_DEF_WIDGET | WDF_STD_BTN | WDF_UNCLICK_BUTTONS | WDF_RESIZABLE,

   230

	_newgrf_add_dlg_widgets,

   231

	NewGRFAddDlgWndProc,

   232

};

   233

   234

   235

/* 'NewGRF Settings' dialogue */

   236

typedef struct newgrf_d {

   237

	GRFConfig **list;

   238

	GRFConfig *sel;

   239

	bool editable;

   240

	bool show_params;

   241

} newgrf_d;

   242

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(newgrf_d));

   243

   244

   245

static void SetupNewGRFState(Window *w)

   246

{

   247

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

   248

   249

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

   250

	SetWindowWidgetsDisabledState(w, disable_all, 4, 5, 6, WIDGET_LIST_END);

   251

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

   252

   253

	if (!disable_all) {

   254

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

   255

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

   256

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

   257

	}

   258

}

   259

   260

   261

static void SetupNewGRFWindow(Window *w)

   262

{

   263

	GRFConfig *c;

   264

	int i;

   265

   266

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

   267

   268

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

   269

	SetVScrollCount(w, i);

   270

}

   271

   272

   273

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

   274

{

   275

	switch (e->event) {

   276

		case WE_PAINT: {

   277

			GRFConfig *c;

   278

			int i, y;

   279

   280

			SetupNewGRFState(w);

   281

   282

			DrawWindowWidgets(w);

   283

   284

			/* Draw NewGRF list */

   285

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

   286

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

   287

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

   288

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

   289

					PalSpriteID pal;

   290

   291

					/* Pick a colour */

   292

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

   293

						pal = PALETTE_TO_RED;

   294

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

   295

						pal = PALETTE_TO_GREEN;

   296

					} else {

   297

						pal = PALETTE_TO_BLUE;

   298

					}

   299

   300

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

   301

					DoDrawString(text, 25, y + 3, WP(w, newgrf_d).sel == c ? 0xC : 0x10);

   302

					y += 14;

   303

				}

   304

			}

   305

   306

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

   307

				/* Draw NewGRF file info */

   308

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

   309

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

   310

			}

   311

   312

			break;

   313

		}

   314

   315

		case WE_INVALIDATE_DATA:

   316

			SetupNewGRFWindow(w);

   317

			break;

   318

   319

		case WE_CLICK:

   320

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

   321

				case 3: { /* Add GRF */

   322

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

   323

					Window *w;

   324

   325

					DeleteWindowByClass(WC_SAVELOAD);

   326

					w = AllocateWindowDesc(&_newgrf_add_dlg_desc);

   327

					w->resize.step_height = 10;

   328

   329

					WP(w, newgrf_add_d).list = list;

   330

					break;

   331

				}

   332

   333

				case 4: { /* Remove GRF */

   334

					GRFConfig **pc, *c, *newsel;

   335

   336

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

   337

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

   338

   339

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

   340

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

   341

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

   342

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

   343

   344

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

   345

							*pc = c->next;

   346

							free(c);

   347

							break;

   348

						}

   349

					}

   350

   351

					WP(w, newgrf_d).sel = newsel;

   352

					SetupNewGRFWindow(w);

   353

					SetWindowDirty(w);

   354

					break;

   355

				}

   356

   357

				case 5: { /* Move GRF up */

   358

					GRFConfig **pc, *c;

   359

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

   360

   361

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

   362

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

   363

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

   364

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

   365

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

   366

							break;

   367

						}

   368

					}

   369

					SetWindowDirty(w);

   370

					break;

   371

				}

   372

   373

				case 6: { /* Move GRF down */

   374

					GRFConfig **pc, *c;

   375

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

   376

   377

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

   378

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

   379

							*pc = c->next;

   380

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

   381

							(*pc)->next = c;

   382

							break;

   383

						}

   384

					}

   385

					SetWindowDirty(w);

   386

					break;

   387

				}

   388

   389

				case 7: { /* Select a GRF */

   390

					GRFConfig *c;

   391

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

   392

   393

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

   394

					WP(w, newgrf_d).sel = c;

   395

   396

					SetWindowDirty(w);

   397

					break;

   398

				}

   399

   400

				case 10: { /* Edit parameters */

   401

					char buff[512];

   402

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

   403

   404

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

   405

					ShowQueryString(BindCString(buff), STR_NEWGRF_PARAMETER_QUERY, 63, 250, w->window_class, w->window_number, CS_ALPHANUMERAL);

   406

					break;

   407

				}

   408

			}

   409

			break;

   410

   411

		case WE_ON_EDIT_TEXT:

   412

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

   413

				/* Parse our new "int list" */

   414

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

   415

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

   416

   417

				/* parse_intlist returns -1 on error */

   418

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

   419

			}

   420

			SetWindowDirty(w);

   421

			break;

   422

   423

		case WE_RESIZE:

   424

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

   425

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

   426

			break;

   427

	}

   428

}

   429

   430

   431

static const Widget _newgrf_widgets[] = {

   432

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

   433

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

   434

   435

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

   436

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

   437

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

   438

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

   439

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

   440

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

   441

   442

/* NewGRF file list */

   443

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

   444

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

   445

   446

/* NewGRF file info */

   447

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

   448

   449

/* Edit parameter button... */

   450

{ WWT_PUSHTXTBTN,   RESIZE_RTB, 10,   0, 287, 200, 211, STR_NEWGRF_SET_PARAMETERS,   STR_NULL },

   451

{  WWT_RESIZEBOX,  RESIZE_LRTB, 10, 288, 299, 200, 211, 0x0,                         STR_RESIZE_BUTTON },

   452

   453

{ WIDGETS_END },

   454

};

   455

   456

   457

static const WindowDesc _newgrf_desc = {

   458

	WDP_CENTER, WDP_CENTER, 300, 212,

   459

	WC_GAME_OPTIONS, 0,

   460

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS | WDF_RESIZABLE,

   461

	_newgrf_widgets,

   462

	NewGRFWndProc,

   463

};

   464

   465

   466

void ShowNewGRFSettings(bool editable, bool show_params, GRFConfig **config)

   467

{

   468

	Window *w;

   469

   470

	DeleteWindowByClass(WC_GAME_OPTIONS);

   471

	w = AllocateWindowDesc(&_newgrf_desc);

   472

	if (w == NULL) return;

   473

   474

	w->resize.step_height = 14;

   475

   476

	/* Clear selections */

   477

	WP(w, newgrf_d).sel         = NULL;

   478

	WP(w, newgrf_d).list        = config;

   479

	WP(w, newgrf_d).editable    = editable;

   480

	WP(w, newgrf_d).show_params = show_params;

   481

   482

	SetupNewGRFWindow(w);

   483

}