1

/* $Id$ */

     2

     3

     4

#include "stdafx.h"

     5

#include "openttd.h"

    20

#include "table/sprites.h"

    21

#include "table/strings.h"

    22

    23

/** @file news_gui.cpp

    24

 *

    25

 * News system is realized as a FIFO queue (in an array)

    26

 * The positions in the queue can't be rearranged, we only access

    27

 * the array elements through pointers to the elements. Once the

    28

 * array is full, the oldest entry (\a _oldest_news) is being overwritten

    29

 * by the newest (\a _latest_news).

    30

 *

    31

 * \verbatim

    32

 * oldest                   current   lastest

    33

 *  |                          |         |

    34

 * [O------------F-------------C---------L           ]

    35

 *               |

    36

 *            forced

    37

 * \endverbatim

    38

 *

    39

 * Of course by using an array we can have situations like

    40

 *

    41

 * \verbatim

    42

 * [----L          O-----F---------C-----------------]

    43

 * This is where we have wrapped around the array and have

    44

 * (MAX_NEWS - O) + L news items

    45

 * \endverbatim

    46

 */

    47

    48

/** Number of news items in the FIFO queue */

    49

#define MAX_NEWS 30

    50

#define NB_WIDG_PER_SETTING 4

    51

    52

typedef byte NewsID;

    53

#define INVALID_NEWS 255

    54

    58

static NewsItem _news_items[MAX_NEWS];      ///< The news FIFO queue

    59

static NewsID _current_news = INVALID_NEWS; ///< points to news item that should be shown next

    60

static NewsID _oldest_news = 0;             ///< points to first item in fifo queue

    61

static NewsID _latest_news = INVALID_NEWS;  ///< points to last item in fifo queue

    62

    63

/** Forced news item.

    64

 * Users can force an item by accessing the history or "last message".

    65

 * If the message being shown was forced by the user, its index is stored in

    66

 * _forced_news. Otherwise, \a _forced_news variable is INVALID_NEWS. */

    67

static NewsID _forced_news = INVALID_NEWS;

    68

    69

static byte _total_news = 0; ///< Number of news items in FIFO queue @see _news_items

    70

    71

void DrawNewsNewVehicleAvail(Window *w);

    72

void DrawNewsBankrupcy(Window *w);

    73

static void MoveToNextItem();

    74

    75

StringID GetNewsStringNewVehicleAvail(const NewsItem *ni);

    76

StringID GetNewsStringBankrupcy(const NewsItem *ni);

    77

    78

static DrawNewsCallbackProc * const _draw_news_callback[] = {

    79

	DrawNewsNewVehicleAvail,  ///< DNC_VEHICLEAVAIL

    80

	DrawNewsBankrupcy,        ///< DNC_BANKRUPCY

    81

};

    82

    83

extern GetNewsStringCallbackProc * const _get_news_string_callback[];

    84

GetNewsStringCallbackProc * const _get_news_string_callback[] = {

    85

	GetNewsStringNewVehicleAvail,  ///< DNC_VEHICLEAVAIL

    86

	GetNewsStringBankrupcy,        ///< DNC_BANKRUPCY

    87

};

    88

    89

/** Initialize the news-items data structures */

    90

void InitNewsItemStructs()

    91

{

    92

	memset(_news_items, 0, sizeof(_news_items));

    93

	_current_news = INVALID_NEWS;

    94

	_oldest_news = 0;

    95

	_latest_news = INVALID_NEWS;

    96

	_forced_news = INVALID_NEWS;

    97

	_total_news = 0;

    98

}

    99

   100

void DrawNewsBorder(const Window *w)

   101

{

   102

	int left = 0;

   103

	int right = w->width - 1;

   104

	int top = 0;

   105

	int bottom = w->height - 1;

   106

   107

	GfxFillRect(left, top, right, bottom, 0xF);

   108

   109

	GfxFillRect(left, top, left, bottom, 0xD7);

   110

	GfxFillRect(right, top, right, bottom, 0xD7);

   111

	GfxFillRect(left, top, right, top, 0xD7);

   112

	GfxFillRect(left, bottom, right, bottom, 0xD7);

   113

   114

	DrawString(left + 2, top + 1, STR_00C6, TC_FROMSTRING);

   115

}

   116

   117

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

   118

{

   119

	switch (e->event) {

   120

	case WE_CREATE: { // If chatbar is open at creation time, we need to go above it

   121

		const Window *w1 = FindWindowById(WC_SEND_NETWORK_MSG, 0);

   122

		w->message.msg = (w1 != NULL) ? w1->height : 0;

   123

	} break;

   124

   125

	case WE_PAINT: {

   126

		const NewsItem *ni = WP(w, news_d).ni;

   127

		ViewPort *vp;

   128

   129

		switch (ni->display_mode) {

   130

			case NM_NORMAL:

   131

			case NM_THIN: {

   132

				DrawNewsBorder(w);

   133

   134

				DrawString(2, 1, STR_00C6, TC_FROMSTRING);

   135

   136

				SetDParam(0, ni->date);

   137

				DrawStringRightAligned(428, 1, STR_01FF, TC_FROMSTRING);

   138

   139

				if (!(ni->flags & NF_VIEWPORT)) {

   140

					CopyInDParam(0, ni->params, lengthof(ni->params));

   141

					DrawStringMultiCenter(215, ni->display_mode == NM_NORMAL ? 76 : 56,

   142

						ni->string_id, w->width - 4);

   143

				} else {

   144

					/* Back up transparency options to draw news view */

   145

					TransparencyOptionBits to_backup = _transparency_opt;

   146

					_transparency_opt = 0;

   147

					DrawWindowViewport(w);

   148

					_transparency_opt = to_backup;

   149

   150

					/* Shade the viewport into gray, or color*/

   151

					vp = w->viewport;

   152

					GfxFillRect(vp->left - w->left, vp->top - w->top,

   153

						vp->left - w->left + vp->width - 1, vp->top - w->top + vp->height - 1,

   154

						(ni->flags & NF_INCOLOR ? PALETTE_TO_TRANSPARENT : PALETTE_TO_STRUCT_GREY) | (1 << USE_COLORTABLE)

   155

					);

   156

   157

					CopyInDParam(0, ni->params, lengthof(ni->params));

   158

					DrawStringMultiCenter(w->width / 2, 20, ni->string_id, w->width - 4);

   159

				}

   160

				break;

   161

			}

   162

   163

			case NM_CALLBACK: {

   164

				_draw_news_callback[ni->callback](w);

   165

				break;

   166

			}

   167

   168

			default: {

   169

				DrawWindowWidgets(w);

   170

				if (!(ni->flags & NF_VIEWPORT)) {

   171

					CopyInDParam(0, ni->params, lengthof(ni->params));

   172

					DrawStringMultiCenter(140, 38, ni->string_id, 276);

   173

				} else {

   174

					DrawWindowViewport(w);

   175

					CopyInDParam(0, ni->params, lengthof(ni->params));

   176

					DrawStringMultiCenter(w->width / 2, w->height - 16, ni->string_id, w->width - 4);

   177

				}

   178

				break;

   179

			}

   180

		}

   181

	} break;

   182

   183

	case WE_CLICK: {

   184

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

   185

		case 1: {

   186

			NewsItem *ni = WP(w, news_d).ni;

   187

			DeleteWindow(w);

   188

			ni->duration = 0;

   189

			_forced_news = INVALID_NEWS;

   190

		} break;

   191

		case 0: {

   192

			NewsItem *ni = WP(w, news_d).ni;

   193

			if (ni->flags & NF_VEHICLE) {

   194

				Vehicle *v = GetVehicle(ni->data_a);

   195

				ScrollMainWindowTo(v->x_pos, v->y_pos);

   196

			} else if (ni->flags & NF_TILE) {

   197

				if (!ScrollMainWindowToTile(ni->data_a) && ni->data_b != 0)

   198

					ScrollMainWindowToTile(ni->data_b);

   199

			}

   200

		} break;

   201

		}

   202

	} break;

   203

   204

	case WE_KEYPRESS:

   205

		if (e->we.keypress.keycode == WKC_SPACE) {

   206

			/* Don't continue. */

   207

			e->we.keypress.cont = false;

   208

			DeleteWindow(w);

   209

		}

   210

		break;

   211

   212

	case WE_MESSAGE: // The chatbar has notified us that is was either created or closed

   213

		switch (e->we.message.msg) {

   214

			case WE_CREATE: w->message.msg = e->we.message.wparam; break;

   215

			case WE_DESTROY: w->message.msg = 0; break;

   216

		}

   217

		break;

   218

   219

	case WE_TICK: { // Scroll up newsmessages from the bottom in steps of 4 pixels

   220

		int diff;

   221

		int y = max(w->top - 4, _screen.height - w->height - 12 - w->message.msg);

   222

		if (y == w->top) return;

   223

   224

		if (w->viewport != NULL)

   225

			w->viewport->top += y - w->top;

   226

   227

		diff = Delta(w->top, y);

   228

		w->top = y;

   229

   230

		SetDirtyBlocks(w->left, w->top - diff, w->left + w->width, w->top + w->height);

   231

	} break;

   232

	}

   233

}

   234

   235

/**

   236

 * Return the correct index in the pseudo-fifo

   237

 * queue and deals with overflows when increasing the index

   238

 */

   239

static inline NewsID increaseIndex(NewsID i)

   240

{

   241

	assert(i != INVALID_NEWS);

   242

	return (i + 1) % MAX_NEWS;

   243

}

   244

   245

/**

   246

 * Return the correct index in the pseudo-fifo

   247

 * queue and deals with overflows when decreasing the index

   248

 */

   249

static inline NewsID decreaseIndex(NewsID i)

   250

{

   251

	assert(i != INVALID_NEWS);

   252

	return (i + MAX_NEWS - 1) % MAX_NEWS;

   253

}

   254

   255

/**

   256

 * Add a new newsitem to be shown.

   257

 * @param string String to display, can have special values based on parameter \a flags

   258

 * @param flags various control bits that will show various news-types. See macro NEWS_FLAGS()

   259

 * @param data_a news-specific value based on news type

   260

 * @param data_b news-specific value based on news type

   261

 * @note flags exists of 4 byte-sized extra parameters.

   262

 *  -# Bits  0 -  7 display_mode, any of the NewsMode enums (NM_)

   263

 *  -# Bits  8 - 15 news flags, any of the NewsFlags enums (NF_)

   264

 *  -# Bits 16 - 23 news category, any of the NewsType enums (NT_)

   265

 *  -# Bits 24 - 31 news callback function, any of the NewsCallback enums (DNC_)

   266

 *

   267

 * If the display mode is NM_CALLBACK, special news is shown and parameter

   268

 * \a string has a special meaning.

   269

 *  - For DNC_TRAINAVAIL, DNC_ROADAVAIL, DNC_SHIPAVAIL, DNC_AIRCRAFTAVAIL messages: StringID is

   270

 *    the index of the engine that is shown

   271

 *

   272

 *  - For DNC_BANKRUPCY: bytes 0-3 of StringID contains the player that is in trouble,

   273

 *    and 4-7 contains what kind of bankrupcy message is shown.

   274

 *    @see NewsBankrupcy

   275

 *

   276

 * @see NewsMode

   277

 * @see NewsFlags

   278

 * @see NewsType

   279

 * @see NewsCallback

   280

 */

   281

void AddNewsItem(StringID string, uint32 flags, uint data_a, uint data_b)

   282

{

   283

	NewsID l_news;

   284

   285

	if (_game_mode == GM_MENU) return;

   286

   287

	/* check the rare case that the oldest (to be overwritten) news item is open */

   288

	if (_total_news == MAX_NEWS && (_oldest_news == _current_news || _oldest_news == _forced_news))

   289

		MoveToNextItem();

   290

   291

	if (_total_news < MAX_NEWS) _total_news++;

   292

   293

	/* Increase _latest_news. If we have no news yet, use _oldest news as an

   294

	 * index. We cannot use 0 as _oldest_news can jump around due to

   295

	 * DeleteVehicleNews */

   296

	l_news = _latest_news;

   297

	_latest_news = (_latest_news == INVALID_NEWS) ? _oldest_news : increaseIndex(_latest_news);

   298

   299

	/* If the fifo-buffer is full, overwrite the oldest entry */

   300

	if (l_news != INVALID_NEWS && _latest_news == _oldest_news) {

   301

		assert(_total_news == MAX_NEWS);

   302

		_oldest_news = increaseIndex(_oldest_news);

   303

	}

   304

   305

	/*DEBUG(misc, 0, "+cur %3d, old %2d, lat %3d, for %3d, tot %2d",

   306

	  _current_news, _oldest_news, _latest_news, _forced_news, _total_news);*/

   307

   308

	/* Add news to _latest_news */

   309

	{

   310

		Window *w;

   311

		NewsItem *ni = &_news_items[_latest_news];

   312

		memset(ni, 0, sizeof(*ni));

   313

   314

		ni->string_id = string;

   315

		ni->display_mode = (byte)flags;

   316

		ni->flags = (byte)(flags >> 8);

   317

   318

		/* show this news message in color? */

   319

		if (_cur_year >= _patches.colored_news_year) ni->flags |= NF_INCOLOR;

   320

   321

		ni->type = (byte)(flags >> 16);

   322

		ni->callback = (byte)(flags >> 24);

   323

		ni->data_a = data_a;

   324

		ni->data_b = data_b;

   325

		ni->date = _date;

   326

		CopyOutDParam(ni->params, 0, lengthof(ni->params));

   327

   328

		w = FindWindowById(WC_MESSAGE_HISTORY, 0);

   329

		if (w == NULL) return;

   330

		SetWindowDirty(w);

   331

		w->vscroll.count = _total_news;

   332

	}

   333

}

   334

   335

   336

/**

   337

 * Maximum age of news items.

   338

 * Don't show item if it's older than x days, corresponds with NewsType in news.h

   339

 * @see NewsType

   340

 */

   341

static const byte _news_items_age[NT_END] = {

   342

	60,  ///< NT_ARRIVAL_PLAYER

   343

	60,  ///< NT_ARRIVAL_OTHER

   344

	90,  ///< NT_ACCIDENT

   345

	60,  ///< NT_COMPANY_INFO

   346

	90,  ///< NT_OPENCLOSE

   347

	30,  ///< NT_ECONOMY

   348

	30,  ///< NT_INDUSTRY_PLAYER

   349

	30,  ///< NT_INDUSTRY_OTHER

   350

	30,  ///< NT_INDUSTRY_NOBODY

   351

	150, ///< NT_ADVICE

   352

	30,  ///< NT_NEW_VEHICLES

   353

	90,  ///< NT_ACCEPTANCE

   354

	180, ///< NT_SUBSIDIES

   355

	60   ///< NT_GENERAL

   356

};

   357

   358

   359

static const Widget _news_type13_widgets[] = {

   360

{      WWT_PANEL,   RESIZE_NONE,    15,     0,   429,     0,   169, 0x0, STR_NULL},

   361

{      WWT_PANEL,   RESIZE_NONE,    15,     0,    10,     0,    11, 0x0, STR_NULL},

   362

{   WIDGETS_END},

   363

};

   364

   365

static WindowDesc _news_type13_desc = {

   366

	WDP_CENTER, 476, 430, 170, 430, 170,

   367

	WC_NEWS_WINDOW, WC_NONE,

   368

	WDF_DEF_WIDGET,

   369

	_news_type13_widgets,

   370

	NewsWindowProc

   371

};

   372

   373

static const Widget _news_type2_widgets[] = {

   374

{      WWT_PANEL,   RESIZE_NONE,    15,     0,   429,     0,   129, 0x0, STR_NULL},

   375

{      WWT_PANEL,   RESIZE_NONE,    15,     0,    10,     0,    11, 0x0, STR_NULL},

   376

{   WIDGETS_END},

   377

};

   378

   379

static WindowDesc _news_type2_desc = {

   380

	WDP_CENTER, 476, 430, 130, 430, 130,

   381

	WC_NEWS_WINDOW, WC_NONE,

   382

	WDF_DEF_WIDGET,

   383

	_news_type2_widgets,

   384

	NewsWindowProc

   385

};

   386

   387

static const Widget _news_type0_widgets[] = {

   388

{      WWT_PANEL,   RESIZE_NONE,     5,     0,   279,    14,    86, 0x0,              STR_NULL},

   389

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

   390

{    WWT_CAPTION,   RESIZE_NONE,     5,    11,   279,     0,    13, STR_012C_MESSAGE, STR_NULL},

   391

{      WWT_INSET,   RESIZE_NONE,     5,     2,   277,    16,    64, 0x0,              STR_NULL},

   392

{   WIDGETS_END},

   393

};

   394

   395

static WindowDesc _news_type0_desc = {

   396

	WDP_CENTER, 476, 280, 87, 280, 87,

   397

	WC_NEWS_WINDOW, WC_NONE,

   398

	WDF_DEF_WIDGET,

   399

	_news_type0_widgets,

   400

	NewsWindowProc

   401

};

   402

   403

static const SoundFx _news_sounds[NT_END] = {

   404

	SND_1D_APPLAUSE,	///< NT_ARRIVAL_PLAYER

   405

	SND_1D_APPLAUSE,	///< NT_ARRIVAL_OTHER

   406

	SND_BEGIN,		///< NT_ACCIDENT

   407

	SND_BEGIN,		///< NT_COMPANY_INFO

   408

	SND_BEGIN,		///< NT_OPENCLOSE

   409

	SND_BEGIN,		///< NT_ECONOMY

   410

	SND_BEGIN,		///< NT_INDUSTRY_PLAYER

   411

	SND_BEGIN,		///< NT_INDUSTRY_OTHER

   412

	SND_BEGIN,		///< NT_INDUSTRY_NOBODY

   413

	SND_BEGIN,		///< NT_ADVICE

   414

	SND_1E_OOOOH,		///< NT_NEW_VEHICLES

   415

	SND_BEGIN,		///< NT_ACCEPTANCE

   416

	SND_BEGIN,		///< NT_SUBSIDIES

   417

	SND_BEGIN,		///< NT_GENERAL

   418

};

   419

   420

const char *_news_display_name[NT_END] = {

   421

	"arrival_player",

   422

	"arrival_other",

   423

	"accident",

   424

	"company_info",

   425

	"openclose",

   426

	"economy",

   427

	"production_player",

   428

	"production_other",

   429

	"production_nobody",

   430

	"advice",

   431

	"new_vehicles",

   432

	"acceptance",

   433

	"subsidies",

   434

	"general",

   435

};

   436

   437

/**

   438

 * Get the value of an item of the news-display settings. This is

   439

 * a little tricky since on/off/summary must use 2 bits to store the value

   440

 * @param item the item whose value is requested

   441

 * @return return the found value which is between 0-2

   442

 */

   443

static inline byte GetNewsDisplayValue(byte item)

   444

{

   445

	assert(item < NT_END && GB(_news_display_opt, item * 2, 2) <= 2);

   446

	return GB(_news_display_opt, item * 2, 2);

   447

}

   448

   449

/**

   450

 * Set the value of an item in the news-display settings. This is

   451

 * a little tricky since on/off/summary must use 2 bits to store the value

   452

 * @param item the item whose value is being set

   453

 * @param val new value

   454

 */

   455

static inline void SetNewsDisplayValue(byte item, byte val)

   456

{

   457

	assert(item < NT_END && val <= 2);

   458

	SB(_news_display_opt, item * 2, 2, val);

   459

}

   460

   461

/** Open up an own newspaper window for the news item */

   462

static void ShowNewspaper(NewsItem *ni)

   463

{

   464

	Window *w;

   465

	SoundFx sound;

   466

	int top;

   467

	ni->flags &= ~NF_FORCE_BIG;

   468

	ni->duration = 555;

   469

   470

	sound = _news_sounds[ni->type];

   471

	if (sound != 0) SndPlayFx(sound);

   472

   473

	top = _screen.height;

   474

	switch (ni->display_mode) {

   475

		case NM_NORMAL:

   476

		case NM_CALLBACK: {

   477

			_news_type13_desc.top = top;

   478

			w = AllocateWindowDesc(&_news_type13_desc);

   479

			if (ni->flags & NF_VIEWPORT)

   480

				AssignWindowViewport(w, 2, 58, 0x1AA, 0x6E,

   481

					ni->data_a | (ni->flags & NF_VEHICLE ? 0x80000000 : 0), ZOOM_LVL_NEWS);

   482

			break;

   483

		}

   484

   485

		case NM_THIN: {

   486

			_news_type2_desc.top = top;

   487

			w = AllocateWindowDesc(&_news_type2_desc);

   488

			if (ni->flags & NF_VIEWPORT)