1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "debug.h"

     6

#include "functions.h"

     7

#include "strings.h"

     8

#include "table/strings.h"

     9

#include "window.h"

    10

#include "gui.h"

    11

#include "station.h"

    12

#include "gfx.h"

    13

#include "player.h"

    14

#include "economy.h"

    15

#include "town.h"

    16

#include "command.h"

    17

#include "variables.h"

    18

#include "vehicle_gui.h"

    19

    20

typedef int CDECL StationSortListingTypeFunction(const void*, const void*);

    21

    22

static StationSortListingTypeFunction StationNameSorter;

    23

static StationSortListingTypeFunction StationTypeSorter;

    24

static StationSortListingTypeFunction StationWaitingSorter;

    25

static StationSortListingTypeFunction StationRatingMaxSorter;

    26

    27

static void StationsWndShowStationRating(int x, int y, int type, uint acceptance, int rating)

    28

{

    29

	static const byte _rating_colors[NUM_CARGO] = {152, 32, 15, 174, 208, 194, 191, 55, 184, 10, 191, 48};

    30

	int color = _rating_colors[type];

    31

	uint w;

    32

    33

	if (acceptance > 575) acceptance = 575;

    34

    35

	acceptance = (acceptance + 7) / 8;

    36

    37

	/* draw cargo */

    38

	w = acceptance / 8;

    39

	if (w != 0) {

    40

		GfxFillRect(x, y, x + w - 1, y + 6, color);

    41

		x += w;

    42

	}

    43

    44

	w = acceptance % 8;

    45

	if (w != 0) {

    46

		if (w == 7) w--;

    47

		GfxFillRect(x, y + (w - 1), x, y + 6, color);

    48

	}

    49

    50

	x -= acceptance / 8;

    51

    52

	DrawString(x + 1, y, _cargoc.names_short[type], 0x10);

    53

    54

	/* draw green/red ratings bar */

    55

	GfxFillRect(x + 1, y + 8, x + 7, y + 8, 0xB8);

    56

    57

	rating >>= 5;

    58

    59

	if (rating != 0) GfxFillRect(x + 1, y + 8, x + rating, y + 8, 0xD0);

    60

}

    61

    62

const StringID _station_sort_listing[] = {

    63

	STR_SORT_BY_DROPDOWN_NAME,

    64

	STR_SORT_BY_FACILITY,

    65

	STR_SORT_BY_WAITING,

    66

	STR_SORT_BY_RATING_MAX,

    67

	INVALID_STRING_ID

    68

};

    69

    70

static char _bufcache[64];

    71

static uint16 _last_station_idx;

    72

static int _internal_sort_order;

    73

    74

static int CDECL StationNameSorter(const void *a, const void *b)

    75

{

    76

	char buf1[64];

    77

	int32 argv[1];

    78

	const SortStruct *cmp1 = (const SortStruct*)a;

    79

	const SortStruct *cmp2 = (const SortStruct*)b;

    80

	int r;

    81

    82

	argv[0] = cmp1->index;

    83

	GetStringWithArgs(buf1, STR_STATION, argv);

    84

    85

	if (cmp2->index != _last_station_idx) {

    86

		_last_station_idx = cmp2->index;

    87

		argv[0] = cmp2->index;

    88

		GetStringWithArgs(_bufcache, STR_STATION, argv);

    89

	}

    90

    91

	r =  strcmp(buf1, _bufcache); // sort by name

    92

	return (_internal_sort_order & 1) ? -r : r;

    93

}

    94

    95

static int CDECL StationTypeSorter(const void *a, const void *b)

    96

{

    97

	const Station *st1 = GetStation(((const SortStruct*)a)->index);

    98

	const Station *st2 = GetStation(((const SortStruct*)b)->index);

    99

	return (_internal_sort_order & 1) ? st2->facilities - st1->facilities : st1->facilities - st2->facilities;

   100

}

   101

   102

static int CDECL StationWaitingSorter(const void *a, const void *b)

   103

{

   104

	int sum1 = 0, sum2 = 0;

   105

	int j;

   106

	const Station *st1 = GetStation(((const SortStruct*)a)->index);

   107

	const Station *st2 = GetStation(((const SortStruct*)b)->index);

   108

   109

	for (j = 0; j < NUM_CARGO; j++) {

   110

		if (st1->goods[j].waiting_acceptance & 0xfff) sum1 += GetTransportedGoodsIncome(st1->goods[j].waiting_acceptance & 0xfff, 20, 50, j);

   111

		if (st2->goods[j].waiting_acceptance & 0xfff) sum2 += GetTransportedGoodsIncome(st2->goods[j].waiting_acceptance & 0xfff, 20, 50, j);

   112

	}

   113

   114

	return (_internal_sort_order & 1) ? sum2 - sum1 : sum1 - sum2;

   115

}

   116

   117

static int CDECL StationRatingMaxSorter(const void *a, const void *b)

   118

{

   119

	byte maxr1 = 0;

   120

	byte maxr2 = 0;

   121

	int j;

   122

	const Station *st1 = GetStation(((const SortStruct*)a)->index);

   123

	const Station *st2 = GetStation(((const SortStruct*)b)->index);

   124

   125

	for (j = 0; j < NUM_CARGO; j++) {

   126

		if (st1->goods[j].waiting_acceptance & 0xfff) maxr1 = max(maxr1, st1->goods[j].rating);

   127

		if (st2->goods[j].waiting_acceptance & 0xfff) maxr2 = max(maxr2, st2->goods[j].rating);

   128

	}

   129

   130

	return (_internal_sort_order & 1) ? maxr2 - maxr1 : maxr1 - maxr2;

   131

}

   132

   133

typedef enum StationListFlags {

   134

	SL_ORDER   = 0x01,

   135

	SL_RESORT  = 0x02,

   136

	SL_REBUILD = 0x04,

   137

} StationListFlags;

   138

   139

typedef struct plstations_d {

   140

	SortStruct *sort_list;

   141

	uint16 list_length;

   142

	byte sort_type;

   143

	StationListFlags flags;

   144

	uint16 resort_timer;  //was byte refresh_counter;

   145

} plstations_d;

   146

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(plstations_d));

   147

   148

void RebuildStationLists(void)

   149

{

   150

	Window *w;

   151

   152

	for (w = _windows; w != _last_window; ++w) {

   153

		if (w->window_class == WC_STATION_LIST) {

   154

			WP(w, plstations_d).flags |= SL_REBUILD;

   155

			SetWindowDirty(w);

   156

		}

   157

	}

   158

}

   159

   160

void ResortStationLists(void)

   161

{

   162

	Window *w;

   163

   164

	for (w = _windows; w != _last_window; ++w) {

   165

		if (w->window_class == WC_STATION_LIST) {

   166

			WP(w, plstations_d).flags |= SL_RESORT;

   167

			SetWindowDirty(w);

   168

		}

   169

	}

   170

}

   171

   172

static void BuildStationsList(plstations_d* sl, PlayerID owner, byte facilities, uint16 cargo_filter)

   173

{

   174

	uint n = 0;

   175

	uint i, j;

   176

	const Station *st;

   177

   178

	if (!(sl->flags & SL_REBUILD)) return;

   179

   180

	/* Create array for sorting */

   181

	_station_sort = realloc(_station_sort, GetStationPoolSize() * sizeof(_station_sort[0]));

   182

	if (_station_sort == NULL)

   183

		error("Could not allocate memory for the station-sorting-list");

   184

   185

	DEBUG(misc, 1) ("Building station list for player %d...", owner);

   186

   187

	FOR_ALL_STATIONS(st) {

   188

		if (st->xy && st->owner == owner) {

   189

			if (facilities & st->facilities) { //only stations with selected facilities

   190

				int num_waiting_cargo = 0;

   191

				for (j = 0; j < NUM_CARGO; j++) {

   192

					if (st->goods[j].waiting_acceptance & 0xFFF) {

   193

						num_waiting_cargo++; //count number of waiting cargo

   194

						if (HASBIT(cargo_filter, j)) {

   195

							_station_sort[n].index = st->index;

   196

							_station_sort[n].owner = st->owner;

   197

							n++;

   198

							break;

   199

						}

   200

					}

   201

				}

   202

				//stations without waiting cargo

   203

				if (num_waiting_cargo == 0 && HASBIT(cargo_filter, NUM_CARGO)) {

   204

					_station_sort[n].index = st->index;

   205

					_station_sort[n].owner = st->owner;

   206

					n++;

   207

				}

   208

			}

   209

		}

   210

	}

   211

   212

	free(sl->sort_list);

   213

	sl->sort_list = malloc(n * sizeof(sl->sort_list[0]));

   214

	if (n != 0 && sl->sort_list == NULL) error("Could not allocate memory for the station-sorting-list");

   215

	sl->list_length = n;

   216

   217

	for (i = 0; i < n; ++i) sl->sort_list[i] = _station_sort[i];

   218

   219

	sl->flags &= ~SL_REBUILD;

   220

	sl->flags |= SL_RESORT;

   221

}

   222

   223

static void SortStationsList(plstations_d *sl)

   224

{

   225

	static StationSortListingTypeFunction* const _station_sorter[] = {

   226

		&StationNameSorter,

   227

		&StationTypeSorter,

   228

		&StationWaitingSorter,

   229

		&StationRatingMaxSorter

   230

	};

   231

   232

	if (!(sl->flags & SL_RESORT)) return;

   233

   234

	_internal_sort_order = sl->flags & SL_ORDER;

   235

	_last_station_idx = 0; // used for "cache" in namesorting

   236

	qsort(sl->sort_list, sl->list_length, sizeof(sl->sort_list[0]), _station_sorter[sl->sort_type]);

   237

   238

	sl->resort_timer = DAY_TICKS * PERIODIC_RESORT_DAYS;

   239

	sl->flags &= ~SL_RESORT;

   240

}

   241

   242

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

   243

{

   244

	const PlayerID owner = w->window_number;

   245

	static byte facilities = FACIL_TRAIN | FACIL_TRUCK_STOP | FACIL_BUS_STOP | FACIL_AIRPORT | FACIL_DOCK;

   246

	static uint16 cargo_filter = 0x1FFF;

   247

	plstations_d *sl = &WP(w, plstations_d);

   248

   249

	switch (e->event) {

   250

	case WE_PAINT: {

   251

		/* Set up cargo click-states. Toggle the all-vehicle and all-cargo types button

   252

		* depending on if all types are clicked or not */

   253

		SB(w->click_state, 6, 5, facilities);

   254

		SB(w->click_state, 26, 1, facilities == (FACIL_TRAIN | FACIL_TRUCK_STOP | FACIL_BUS_STOP | FACIL_AIRPORT | FACIL_DOCK));

   255

		SB(w->click_state, 12, NUM_CARGO + 1, cargo_filter);

   256

		SB(w->click_state, 27, 1, cargo_filter == 0x1FFF);

   257

   258

		BuildStationsList(sl, owner, facilities, cargo_filter);

   259

		SortStationsList(sl);

   260

   261

		SetVScrollCount(w, sl->list_length);

   262

   263

		/* draw widgets, with player's name in the caption */

   264

		{

   265

			const Player* p = GetPlayer(owner);

   266

			SetDParam(0, p->name_1);

   267

			SetDParam(1, p->name_2);

   268

			SetDParam(2, w->vscroll.count);

   269

			DrawWindowWidgets(w);

   270

		}

   271

   272

		{

   273

			int max;

   274

			int i;

   275

			int x = 0, y = 0, xb = 2; // offset from top of widget

   276

			static const byte _cargo_legend_colors[NUM_CARGO] = {152, 32, 15, 174, 208, 194, 191, 84, 184, 10, 202, 215};

   277

   278

			/* draw sorting criteria string */

   279

			DrawString(85, 26, _station_sort_listing[sl->sort_type], 0x10);

   280

			/* draw arrow pointing up/down for ascending/descending sorting */

   281

			DoDrawString(sl->flags & SL_ORDER ? DOWNARROW : UPARROW, 69, 26, 0x10);

   282

   283

   284

			x = 90;

   285

			y = 14;

   286

   287

			for (i = 0; i < NUM_CARGO; i++) {

   288

				GfxFillRect(x + 1, y + 2, x + 11, y + 8, _cargo_legend_colors[i]);

   289

				DrawString(x + 3, y + 2, _cargoc.names_short[i], i == 11 ? 15 : 16);

   290

				x += 14;

   291

			}

   292

   293

			DrawString(x + 2, y + 2, STR_ABBREV_NONE, 16);

   294

			x += 14;

   295

			DrawString(x + 2, y + 2, STR_ABBREV_ALL, 16);

   296

			DrawString(72, y + 2, STR_ABBREV_ALL, 16);

   297

   298

			if (w->vscroll.count == 0) { // player has no stations

   299

				DrawString(xb, 40, STR_304A_NONE, 0);

   300

				return;

   301

			}

   302

   303

			max = min(w->vscroll.pos + w->vscroll.cap, sl->list_length);

   304

			y = 40; // start of the list-widget

   305

   306

			for (i = w->vscroll.pos; i < max; ++i) { // do until max number of stations of owner

   307

				Station* st = GetStation(sl->sort_list[i].index);

   308

				uint j;

   309

				int x;

   310

   311

				assert(st->xy);

   312

				assert(st->owner == owner);

   313

   314

				SetDParam(0, st->index);

   315

				SetDParam(1, st->facilities);

   316

				x = DrawString(xb, y, STR_3049_0, 0) + 5;

   317

   318

				// show cargo waiting and station ratings

   319

				for (j = 0; j != NUM_CARGO; j++) {

   320

					uint acc = GB(st->goods[j].waiting_acceptance, 0, 12);

   321

   322

					if (acc != 0) {

   323

						StationsWndShowStationRating(x, y, j, acc, st->goods[j].rating);

   324

						x += 10;

   325

					}

   326

				}

   327

				y += 10;

   328

			}

   329

		}

   330

	} break;

   331

	case WE_CLICK: {

   332

		switch (e->click.widget) {

   333

		case 3: {

   334

			uint32 id_v = (e->click.pt.y - 41) / 10;

   335

   336

			if (id_v >= w->vscroll.cap) return; // click out of bounds

   337

   338

			id_v += w->vscroll.pos;

   339

   340

			if (id_v >= sl->list_length) return; // click out of list bound

   341

   342

			{

   343

				const Station *st = GetStation(sl->sort_list[id_v].index);

   344

   345

				assert(st->owner == owner);

   346

				ScrollMainWindowToTile(st->xy);

   347

			}

   348

		} break;

   349

		case 6: /* train */

   350

		case 7: /* truck */

   351

		case 8: /* bus */

   352

		case 9: /* airport */

   353

		case 10: /* dock */

   354

			if (_ctrl_pressed) {

   355

				TOGGLEBIT(facilities, e->click.widget - 6);

   356

			} else {

   357

				facilities = 0;

   358

				SETBIT(facilities, e->click.widget - 6);

   359

			}

   360

			sl->flags |= SL_REBUILD;

   361

			SetWindowDirty(w);

   362

		break;

   363

		case 26:

   364

			facilities = FACIL_TRAIN | FACIL_TRUCK_STOP | FACIL_BUS_STOP | FACIL_AIRPORT | FACIL_DOCK;

   365

			sl->flags |= SL_REBUILD;

   366

			SetWindowDirty(w);

   367

			break;

   368

		case 27:

   369

			cargo_filter = 0x1FFF; /* select everything */

   370

			sl->flags |= SL_REBUILD;

   371

			SetWindowDirty(w);

   372

			break;

   373

		case 28: /*flip sorting method asc/desc*/

   374

			TOGGLEBIT(sl->flags, 0); //DESC-flag

   375

			sl->flags |= SL_RESORT;

   376

			SetWindowDirty(w);

   377

		break;

   378

		case 29: case 30: /* select sorting criteria dropdown menu */

   379

			ShowDropDownMenu(w, _station_sort_listing, sl->sort_type, 30, 0, 0);

   380

		break;

   381

		default:

   382

			if (e->click.widget >= 12 && e->click.widget <= 24) { //change cargo_filter

   383

				if (_ctrl_pressed) {

   384

					TOGGLEBIT(cargo_filter, e->click.widget - 12);

   385

				} else {

   386

					cargo_filter = 0;

   387

					SETBIT(cargo_filter, e->click.widget - 12);

   388

				}

   389

				sl->flags |= SL_REBUILD;

   390

				SetWindowDirty(w);

   391

			}

   392

		}

   393

	} break;

   394

	case WE_DROPDOWN_SELECT: /* we have selected a dropdown item in the list */

   395

		if (sl->sort_type != e->dropdown.index) {

   396

			// value has changed -> resort

   397

			sl->sort_type = e->dropdown.index;

   398

			sl->flags |= SL_RESORT;

   399

		}

   400

		SetWindowDirty(w);

   401

		break;

   402

   403

	case WE_TICK:

   404

		if (--sl->resort_timer == 0) {

   405

			DEBUG(misc, 1) ("Periodic rebuild station list player %d", owner);

   406

			sl->resort_timer = DAY_TICKS * PERIODIC_RESORT_DAYS;

   407

			sl->flags |= VL_REBUILD;

   408

			SetWindowDirty(w);

   409

		}

   410

		break;

   411

   412

	case WE_CREATE: /* set up resort timer */

   413

		sl->sort_list = NULL;

   414

		sl->flags = SL_REBUILD;

   415

		sl->sort_type = 0;

   416

		sl->resort_timer = DAY_TICKS * PERIODIC_RESORT_DAYS;

   417

		break;

   418

   419

	case WE_RESIZE:

   420

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

   421

		break;

   422

	}

   423

}

   424

   425

static const Widget _player_stations_widgets[] = {

   426

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

   427

{    WWT_CAPTION,  RESIZE_RIGHT,    14,    11,   345,     0,    13, STR_3048_STATIONS, STR_018C_WINDOW_TITLE_DRAG_THIS},

   428

{  WWT_STICKYBOX,     RESIZE_LR,    14,   346,   357,     0,    13, 0x0,               STR_STICKY_BUTTON},

   429

{      WWT_PANEL,     RESIZE_RB,    14,     0,   345,    37,   161, 0x0,               STR_3057_STATION_NAMES_CLICK_ON},

   430

{  WWT_SCROLLBAR,    RESIZE_LRB,    14,   346,   357,    25,   149, 0x0,               STR_0190_SCROLL_BAR_SCROLLS_LIST},

   431

{  WWT_RESIZEBOX,   RESIZE_LRTB,    14,   346,   357,   150,   161, 0x0,               STR_RESIZE_BUTTON},

   432

//Index 6

   433

{    WWT_TEXTBTN,   RESIZE_NONE,    14,     0,    13,    14,    24, STR_TRAIN, STR_USE_CTRL_TO_SELECT_MORE},

   434

{    WWT_TEXTBTN,   RESIZE_NONE,    14,    14,    27,    14,    24, STR_LORRY, STR_USE_CTRL_TO_SELECT_MORE},

   435

{    WWT_TEXTBTN,   RESIZE_NONE,    14,    28,    41,    14,    24, STR_BUS,   STR_USE_CTRL_TO_SELECT_MORE},

   436

{    WWT_TEXTBTN,   RESIZE_NONE,    14,    42,    55,    14,    24, STR_PLANE, STR_USE_CTRL_TO_SELECT_MORE},

   437

{    WWT_TEXTBTN,   RESIZE_NONE,    14,    56,    69,    14,    24, STR_SHIP,  STR_USE_CTRL_TO_SELECT_MORE},

   438

//Index 11

   439

{      WWT_PANEL,   RESIZE_NONE,    14,    83,    88,    14,    24, 0x0, STR_USE_CTRL_TO_SELECT_MORE},

   440

{      WWT_PANEL,   RESIZE_NONE,    14,    89,   102,    14,    24, 0x0, STR_USE_CTRL_TO_SELECT_MORE},

   441

{      WWT_PANEL,   RESIZE_NONE,    14,   103,   116,    14,    24, 0x0, STR_USE_CTRL_TO_SELECT_MORE},

   442

{      WWT_PANEL,   RESIZE_NONE,    14,   117,   130,    14,    24, 0x0, STR_USE_CTRL_TO_SELECT_MORE},

   443

{      WWT_PANEL,   RESIZE_NONE,    14,   131,   144,    14,    24, 0x0, STR_USE_CTRL_TO_SELECT_MORE},

   444

{      WWT_PANEL,   RESIZE_NONE,    14,   145,   158,    14,    24, 0x0, STR_USE_CTRL_TO_SELECT_MORE},

   445

{      WWT_PANEL,   RESIZE_NONE,    14,   159,   172,    14,    24, 0x0, STR_USE_CTRL_TO_SELECT_MORE},

   446

{      WWT_PANEL,   RESIZE_NONE,    14,   173,   186,    14,    24, 0x0, STR_USE_CTRL_TO_SELECT_MORE},

   447

{      WWT_PANEL,   RESIZE_NONE,    14,   187,   200,    14,    24, 0x0, STR_USE_CTRL_TO_SELECT_MORE},

   448

{      WWT_PANEL,   RESIZE_NONE,    14,   201,   214,    14,    24, 0x0, STR_USE_CTRL_TO_SELECT_MORE},

   449

{      WWT_PANEL,   RESIZE_NONE,    14,   215,   228,    14,    24, 0x0, STR_USE_CTRL_TO_SELECT_MORE},

   450

{      WWT_PANEL,   RESIZE_NONE,    14,   229,   242,    14,    24, 0x0, STR_USE_CTRL_TO_SELECT_MORE},

   451

{      WWT_PANEL,   RESIZE_NONE,    14,   243,   256,    14,    24, 0x0, STR_USE_CTRL_TO_SELECT_MORE},

   452

{      WWT_PANEL,   RESIZE_NONE,    14,   257,   270,    14,    24, 0x0, STR_NO_WAITING_CARGO},

   453

{      WWT_PANEL,  RESIZE_RIGHT,    14,   285,   357,    14,    24, 0x0, STR_NULL},

   454

   455

//26

   456

{      WWT_PANEL,   RESIZE_NONE,    14,    70,    83,    14,    24, 0x0, STR_SELECT_ALL_FACILITIES},

   457

{      WWT_PANEL,   RESIZE_NONE,    14,   271,   284,    14,    24, 0x0, STR_SELECT_ALL_TYPES},

   458

   459

//28

   460

{ WWT_PUSHTXTBTN,   RESIZE_NONE,    14,     0,    80,    25,    36, STR_SORT_BY, STR_SORT_ORDER_TIP},

   461

{      WWT_PANEL,   RESIZE_NONE,    14,    81,   232,    25,    36, 0x0,         STR_SORT_CRITERIA_TIP},

   462

{    WWT_TEXTBTN,   RESIZE_NONE,    14,   233,   243,    25,    36, STR_0225,    STR_SORT_CRITERIA_TIP},

   463

{      WWT_PANEL,  RESIZE_RIGHT,    14,   244,   345,    25,    36, 0x0,         STR_NULL},

   464

{   WIDGETS_END},

   465

};

   466

   467

static const WindowDesc _player_stations_desc = {

   468

	-1, -1, 358, 162,

   469

	WC_STATION_LIST,0,

   470

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS | WDF_STICKY_BUTTON | WDF_RESIZABLE,

   471

	_player_stations_widgets,

   472

	PlayerStationsWndProc

   473

};

   474

   475

   476

void ShowPlayerStations(PlayerID player)

   477

{

   478

	Window *w;

   479

   480

	w = AllocateWindowDescFront(&_player_stations_desc, player);

   481

	if (w != NULL) {

   482

		w->caption_color = (byte)w->window_number;

   483

		w->vscroll.cap = 12;

   484

		w->resize.step_height = 10;

   485

		w->resize.height = w->height - 10 * 7; // minimum if 5 in the list

   486

	}

   487

}

   488

   489

static const Widget _station_view_expanded_widgets[] = {

   490

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

   491

{    WWT_CAPTION,   RESIZE_NONE,    14,    11,   236,     0,    13, STR_300A_0,        STR_018C_WINDOW_TITLE_DRAG_THIS},

   492

{  WWT_STICKYBOX,   RESIZE_NONE,    14,   237,   248,     0,    13, 0x0,               STR_STICKY_BUTTON},

   493

{     WWT_IMGBTN,   RESIZE_NONE,    14,     0,   236,    14,    65, 0x0,               STR_NULL},