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

    13

    14

    15

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

    16

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

    17

 * comma or a space character

    18

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

    19

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

    20

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

    21

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

    22

{

    23

	int n = 0, v;

    24

	char *end;

    25

    26

	for (;;) {

    27

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

    28

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

    29

		p = end;

    30

		items[n++] = v;

    31

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

    32

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

    33

		p++;

    34

	}

    35

    36

	return n;

    37

}

    38

    39

    40

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

    41

{

    42

	char buff[512];

    43

	char *s;

    44

	uint i;

    45

    46

	/* Draw filename */

    47

	SetDParamStr(0, c->filename);

    48

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

    49

    50

	/* Prepare and draw GRF ID */

    51

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

    52

	SetDParamStr(0, buff);

    53

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

    54

    55

	/* Prepare and draw MD5 sum */

    56

	s = buff;

    57

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

    58

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

    59

	}

    60

	SetDParamStr(0, buff);

    61

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

    62

    63

	/* Show GRF parameter list */

    64

	if (show_params) {

    65

		if (c->num_params > 0) {

    66

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

    67

			SetDParamStr(0, buff);

    68

		} else {

    69

			SetDParam(0, STR_01A9_NONE);

    70

		}

    71

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

    72

	}

    73

    74

	/* Show flags */

    75

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

    76

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

    77

    78

	/* Draw GRF info if it exists */

    79

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

    80

		SetDParamStr(0, c->info);

    81

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

    82

	} else {

    83

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

    84

	}

    85

}

    86

    87

    88

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

    89

typedef struct newgrf_add_d {

    90

	GRFConfig **list;

    91

	const GRFConfig *sel;

    92

} newgrf_add_d;

    93

    94

    95

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

    96

{

    97

	switch (e->event) {

    98

		case WE_PAINT: {

    99

			const GRFConfig *c;

   100

			int y;

   101

			int n = 0;

   102

   103

			/* Count the number of GRFs */

   104

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

   105

   106

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

   107

			SetVScrollCount(w, n);

   108

   109

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

   110

			DrawWindowWidgets(w);

   111

   112

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

   113

   114

			n = 0;

   115

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

   116

   117

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

   118

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

   119

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

   120

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

   121

   122

					/* Draw selection background */

   123

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

   124

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

   125

					y += 10;

   126

				}

   127

				n++;

   128

			}

   129

   130

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

   131

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

   132

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

   133

			}

   134

			break;

   135

		}

   136

   137

		case WE_CLICK:

   138

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

   139

				case 3: {

   140

					// Get row...

   141

					const GRFConfig *c;

   142

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

   143

   144

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

   145

					WP(w, newgrf_add_d).sel = c;

   146

					SetWindowDirty(w);

   147

					break;

   148

				}

   149

   150

				case 6: /* Add selection to list */

   151

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

   152

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

   153

						GRFConfig **list, *c;

   154

   155

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

   156

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

   157

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

   158

								ShowErrorMessage(INVALID_STRING_ID, STR_NEWGRF_DUPLICATE_GRFID, 0, 0);

   159

								return;

   160

							}

   161

						}

   162

   163

						/* Copy GRF details from scanned list */

   164

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

   165

						*c = *src;

   166

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

   167

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

   168

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

   169

						c->next = NULL;

   170

   171

						/* Append GRF config to configuration list */

   172

						*list = c;

   173

   174

						DeleteWindowByClass(WC_SAVELOAD);

   175

						InvalidateWindowData(WC_GAME_OPTIONS, 0);

   176

					}

   177

					break;

   178

   179

				case 7: /* Rescan list */

   180

					WP(w, newgrf_add_d).sel = NULL;

   181

					ScanNewGRFFiles();

   182

					SetWindowDirty(w);

   183

					break;

   184

			}

   185

			break;

   186

	}

   187

}

   188

   189

   190

static const Widget _newgrf_add_dlg_widgets[] = {

   191

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

   192

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

   193

   194

/* List of files */

   195

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

   196

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

   197

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

   198

   199

/* NewGRF file info */

   200

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

   201

   202

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

   203

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

   204

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

   205

{   WIDGETS_END },

   206

};

   207

   208

   209

static const WindowDesc _newgrf_add_dlg_desc = {

   210

	WDP_CENTER, WDP_CENTER, 307, 324,

   211

	WC_SAVELOAD, 0,

   212

	WDF_STD_TOOLTIPS | WDF_DEF_WIDGET | WDF_STD_BTN | WDF_UNCLICK_BUTTONS | WDF_RESIZABLE,

   213

	_newgrf_add_dlg_widgets,

   214

	NewGRFAddDlgWndProc,

   215

};

   216

   217

   218

/* 'NewGRF Settings' dialogue */

   219

typedef struct newgrf_d {

   220

	GRFConfig **list;

   221

	GRFConfig *sel;

   222

	bool editable;

   223

	bool show_params;

   224

} newgrf_d;

   225

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(newgrf_d));

   226

   227

   228

static void SetupNewGRFState(Window *w)

   229

{

   230

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

   231

   232

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

   233

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

   234

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

   235

   236

	if (!disable_all) {

   237

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

   238

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

   239

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

   240

	}

   241

}

   242

   243

   244

static void SetupNewGRFWindow(Window *w)

   245

{

   246

	GRFConfig *c;

   247

	int i;

   248

   249

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

   250

   251

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

   252

	SetVScrollCount(w, i);

   253

}

   254

   255

   256

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

   257

{

   258

	switch (e->event) {

   259

		case WE_PAINT: {

   260

			GRFConfig *c;

   261

			int i, y;

   262

   263

			SetupNewGRFState(w);

   264

   265

			DrawWindowWidgets(w);

   266

   267

			/* Draw NewGRF list */

   268

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

   269

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

   270

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

   271

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

   272

					PalSpriteID pal;

   273

   274

					/* Pick a colour */

   275

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

   276

						pal = PALETTE_TO_RED;

   277

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

   278

						pal = PALETTE_TO_GREEN;

   279

					} else {

   280

						pal = PALETTE_TO_BLUE;

   281

					}

   282

   283

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

   284

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

   285

					y += 14;

   286

				}

   287

			}

   288

   289

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

   290

				/* Draw NewGRF file info */

   291

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

   292

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

   293

			}

   294

   295

			break;

   296

		}

   297

   298

		case WE_INVALIDATE_DATA:

   299

			SetupNewGRFWindow(w);

   300

			break;

   301

   302

		case WE_CLICK:

   303

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

   304

				case 3: { /* Add GRF */

   305

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

   306

					Window *w;

   307

   308

					DeleteWindowByClass(WC_SAVELOAD);

   309

					w = AllocateWindowDesc(&_newgrf_add_dlg_desc);

   310

					w->resize.step_height = 10;

   311

   312

					WP(w, newgrf_add_d).list = list;

   313

					break;

   314

				}

   315

   316

				case 4: { /* Remove GRF */

   317

					GRFConfig **pc, *c, *newsel;

   318

   319

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

   320

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

   321

   322

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

   323

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

   324

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

   325

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

   326

   327

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

   328

							*pc = c->next;

   329

							free(c);

   330

							break;

   331

						}

   332

					}

   333

   334

					WP(w, newgrf_d).sel = newsel;

   335

					SetupNewGRFWindow(w);

   336

					SetWindowDirty(w);

   337

					break;

   338

				}

   339

   340

				case 5: { /* Move GRF up */

   341

					GRFConfig **pc, *c;

   342

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

   343

   344

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

   345

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

   346

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

   347

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

   348

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

   349

							break;

   350

						}

   351

					}

   352

					SetWindowDirty(w);

   353

					break;

   354

				}

   355

   356

				case 6: { /* Move GRF down */

   357

					GRFConfig **pc, *c;

   358

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

   359

   360

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

   361

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

   362

							*pc = c->next;

   363

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

   364

							(*pc)->next = c;

   365

							break;

   366

						}

   367

					}

   368

					SetWindowDirty(w);

   369

					break;

   370

				}

   371

   372

				case 7: { /* Select a GRF */

   373

					GRFConfig *c;

   374

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

   375

   376

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

   377

					WP(w, newgrf_d).sel = c;

   378

   379

					SetWindowDirty(w);

   380

					break;

   381

				}

   382

   383

				case 10: { /* Edit parameters */

   384

					char buff[512];

   385

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

   386

   387

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

   388

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

   389

					break;

   390

				}

   391

			}

   392

			break;

   393

   394

		case WE_ON_EDIT_TEXT:

   395

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

   396

				/* Parse our new "int list" */

   397

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

   398

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

   399

   400

				/* parse_intlist returns -1 on error */

   401

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

   402

			}

   403

			SetWindowDirty(w);

   404

			break;

   405

   406

		case WE_RESIZE:

   407

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

   408

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

   409

			break;

   410

	}

   411

}

   412

   413

   414

static const Widget _newgrf_widgets[] = {

   415

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

   416

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

   417

   418

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

   419

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

   420

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

   421

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

   422

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

   423

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

   424

   425

/* NewGRF file list */

   426

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

   427

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

   428

   429

/* NewGRF file info */

   430

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

   431

   432

/* Edit parameter button... */

   433

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

   434

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

   435

   436

{ WIDGETS_END },

   437

};

   438

   439

   440

static const WindowDesc _newgrf_desc = {

   441

	WDP_CENTER, WDP_CENTER, 300, 212,

   442

	WC_GAME_OPTIONS, 0,

   443

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS | WDF_RESIZABLE,

   444

	_newgrf_widgets,

   445

	NewGRFWndProc,

   446

};

   447

   448

   449

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

   450

{

   451

	Window *w;

   452

   453

	DeleteWindowByClass(WC_GAME_OPTIONS);

   454

	w = AllocateWindowDesc(&_newgrf_desc);

   455

	if (w == NULL) return;

   456

   457

	w->resize.step_height = 14;

   458

   459

	/* Clear selections */

   460

	WP(w, newgrf_d).sel         = NULL;

   461

	WP(w, newgrf_d).list        = config;

   462

	WP(w, newgrf_d).editable    = editable;

   463

	WP(w, newgrf_d).show_params = show_params;

   464

   465

	SetupNewGRFWindow(w);

   466

}