1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "table/strings.h"

     6

#include "table/sprites.h"

     7

#include "functions.h"

     8

#include "window.h"

     9

#include "gui.h"

    10

#include "gfx.h"

    11

#include "player.h"

    12

#include "economy.h"

    13

#include "signs.h"

    14

#include "strings.h"

    15

#include "debug.h"

    16

#include "variables.h"

    17

#include "date.h"

    18

    19

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

    20

    21

static uint _legend_excludebits;

    22

static uint _legend_cargobits;

    23

    24

/************************/

    25

/* GENERIC GRAPH DRAWER */

    26

/************************/

    27

    28

enum {GRAPH_NUM = 16};

    29

    30

typedef struct GraphDrawer {

    31

	uint sel; // bitmask of the players *excluded* (e.g. 11111111 means that no players are shown)

    32

	byte num_dataset;

    33

	byte num_on_x_axis;

    34

	byte month;

    35

	Year year;

    36

	bool include_neg;

    37

	byte num_vert_lines;

    38

	uint16 unk61A;

    39

	uint16 unk61C;

    40

	int left, top;

    41

	uint height;

    42

	StringID format_str_y_axis;

    43

	byte color_3, color_2, bg_line_color;

    44

	byte colors[GRAPH_NUM];

    45

	uint64 cost[GRAPH_NUM][24]; // last 2 years

    46

} GraphDrawer;

    47

    48

#define INVALID_VALUE 0x80000000

    49

    50

static void DrawGraph(const GraphDrawer *gw)

    51

{

    52

    53

	int i,j,k;

    54

	uint x,y,old_x,old_y;

    55

	int color;

    56

	int right, bottom;

    57

	int num_x, num_dataset;

    58

	const uint64 *row_ptr, *col_ptr;

    59

	int64 mx;

    60

	int adj_height;

    61

	uint64 y_scaling, tmp;

    62

	int64 value;

    63

	int64 cur_val;

    64

	uint sel;

    65

    66

	/* the colors and cost array of GraphDrawer must accomodate

    67

	 * both values for cargo and players. So if any are higher, quit */

    68

	assert(GRAPH_NUM >= NUM_CARGO && GRAPH_NUM >= MAX_PLAYERS);

    69

    70

	color = _colour_gradient[gw->bg_line_color][4];

    71

    72

	/* draw the vertical lines */

    73

	i = gw->num_vert_lines; assert(i > 0);

    74

	x = gw->left + 66;

    75

	bottom = gw->top + gw->height - 1;

    76

	do {

    77

		GfxFillRect(x, gw->top, x, bottom, color);

    78

		x += 22;

    79

	} while (--i);

    80

    81

	/* draw the horizontal lines */

    82

	i = 9;

    83

	x = gw->left + 44;

    84

	y = gw->height + gw->top;

    85

	right = gw->left + 44 + gw->num_vert_lines*22-1;

    86

    87

	do {

    88

		GfxFillRect(x, y, right, y, color);

    89

		y -= gw->height >> 3;

    90

	} while (--i);

    91

    92

	/* draw vertical edge line */

    93

	GfxFillRect(x, gw->top, x, bottom, gw->color_2);

    94

    95

	adj_height = gw->height;

    96

	if (gw->include_neg) adj_height >>= 1;

    97

    98

	/* draw horiz edge line */

    99

	y = adj_height + gw->top;

   100

	GfxFillRect(x, y, right, y, gw->color_2);

   101

   102

	/* find the max element */

   103

	if (gw->num_on_x_axis == 0)

   104

		return;

   105

   106

	num_dataset = gw->num_dataset;

   107

	assert(num_dataset > 0);

   108

   109

	row_ptr = gw->cost[0];

   110

	mx = 0;

   111

		/* bit selection for the showing of various players, base max element

   112

		 * on to-be shown player-information. This way the graph can scale */

   113

	sel = gw->sel;

   114

	do {

   115

		if (!(sel&1)) {

   116

			num_x = gw->num_on_x_axis;

   117

			assert(num_x > 0);

   118

			col_ptr = row_ptr;

   119

			do {

   120

				if (*col_ptr != INVALID_VALUE) {

   121

					mx = max64(mx, myabs64(*col_ptr));

   122

				}

   123

			} while (col_ptr++, --num_x);

   124

		}

   125

	} while (sel>>=1, row_ptr+=24, --num_dataset);

   126

   127

	/* setup scaling */

   128

	y_scaling = INVALID_VALUE;

   129

	value = adj_height * 2;

   130

   131

	if (mx > value) {

   132

		mx = (mx + 7) & ~7;

   133

		y_scaling = (((uint64) (value>>1) << 32) / mx);

   134

		value = mx;

   135

	}

   136

   137

	/* draw text strings on the y axis */

   138

	tmp = value;

   139

	if (gw->include_neg) tmp >>= 1;

   140

	x = gw->left + 45;

   141

	y = gw->top - 3;

   142

	i = 9;

   143

	do {

   144

		SetDParam(0, gw->format_str_y_axis);

   145

		SetDParam64(1, (int64)tmp);

   146

		tmp -= (value >> 3);

   147

		DrawStringRightAligned(x, y, STR_0170, gw->color_3);

   148

		y += gw->height >> 3;

   149

	} while (--i);

   150

   151

	/* draw strings on the x axis */

   152

	if (gw->month != 0xFF) {

   153

		x = gw->left + 44;

   154

		y = gw->top + gw->height + 1;

   155

		j = gw->month;

   156

		k = gw->year;

   157

		i = gw->num_on_x_axis;assert(i>0);

   158

		do {

   159

			SetDParam(2, k);

   160

			SetDParam(0, j + STR_0162_JAN);

   161

			SetDParam(1, j + STR_0162_JAN + 2);

   162

			DrawString(x, y, j == 0 ? STR_016F : STR_016E, gw->color_3);

   163

   164

			j += 3;

   165

			if (j >= 12) {

   166

				j = 0;

   167

				k++;

   168

			}

   169

			x += 22;

   170

		} while (--i);

   171

	} else {

   172

		x = gw->left + 52;

   173

		y = gw->top + gw->height + 1;

   174

		j = gw->unk61A;

   175

		i = gw->num_on_x_axis;assert(i>0);

   176

		do {

   177

			SetDParam(0, j);

   178

			DrawString(x, y, STR_01CB, gw->color_3);

   179

			j += gw->unk61C;

   180

			x += 22;

   181

		} while (--i);

   182

	}

   183

   184

	/* draw lines and dots */

   185

	i = 0;

   186

	row_ptr = gw->cost[0];

   187

	sel = gw->sel; // show only selected lines. GraphDrawer qw->sel set in Graph-Legend (_legend_excludebits)

   188

	do {

   189

		if (!(sel & 1)) {

   190

			x = gw->left + 55;

   191

			j = gw->num_on_x_axis;assert(j>0);

   192

			col_ptr = row_ptr;

   193

			color = gw->colors[i];

   194

			old_y = old_x = INVALID_VALUE;

   195

			do {

   196

				cur_val = *col_ptr++;

   197

				if (cur_val != INVALID_VALUE) {

   198

					y = adj_height - BIGMULSS64(cur_val, y_scaling >> 1, 31) + gw->top;

   199

   200

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

   201

					if (old_x != INVALID_VALUE)

   202

						GfxDrawLine(old_x, old_y, x, y, color);

   203

   204

					old_x = x;

   205

					old_y = y;

   206

				} else {

   207

					old_x = INVALID_VALUE;

   208

				}

   209

			} while (x+=22,--j);

   210

		}

   211

	} while (sel>>=1,row_ptr+=24, ++i < gw->num_dataset);

   212

}

   213

   214

/****************/

   215

/* GRAPH LEGEND */

   216

/****************/

   217

   218

void DrawPlayerIcon(PlayerID p, int x, int y)

   219

{

   220

	DrawSprite(SPRITE_PALETTE(PLAYER_SPRITE_COLOR(p) + 0x2EB), x, y);

   221

}

   222

   223

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

   224

{

   225

	const Player* p;

   226

   227

	switch (e->event) {

   228

	case WE_CREATE: {

   229

		uint i;

   230

		for (i = 3; i < w->widget_count; i++) {

   231

			if (!HASBIT(_legend_excludebits, i - 3)) LowerWindowWidget(w, i);

   232

		}

   233

		break;

   234

	}

   235

   236

	case WE_PAINT:

   237

		FOR_ALL_PLAYERS(p) {

   238

			if (!p->is_active) {

   239

				SETBIT(_legend_excludebits, p->index);

   240

				RaiseWindowWidget(w, p->index + 3);

   241

			}

   242

		}

   243

		DrawWindowWidgets(w);

   244

   245

		FOR_ALL_PLAYERS(p) {

   246

			if (!p->is_active) continue;

   247

   248

			DrawPlayerIcon(p->index, 4, 18+p->index*12);

   249

   250

			SetDParam(0, p->name_1);

   251

			SetDParam(1, p->name_2);

   252

			SetDParam(2, GetPlayerNameString(p->index, 3));

   253

			DrawString(21,17+p->index*12,STR_7021,HASBIT(_legend_excludebits, p->index) ? 0x10 : 0xC);

   254

		}

   255

		break;

   256

   257

	case WE_CLICK:

   258

		if (IS_INT_INSIDE(e->we.click.widget, 3, 11)) {

   259

			_legend_excludebits ^= (1 << (e->we.click.widget - 3));

   260

			ToggleWidgetLoweredState(w, e->we.click.widget);

   261

			SetWindowDirty(w);

   262

			InvalidateWindow(WC_INCOME_GRAPH, 0);

   263

			InvalidateWindow(WC_OPERATING_PROFIT, 0);

   264

			InvalidateWindow(WC_DELIVERED_CARGO, 0);

   265

			InvalidateWindow(WC_PERFORMANCE_HISTORY, 0);

   266

			InvalidateWindow(WC_COMPANY_VALUE, 0);

   267

		}

   268

		break;

   269

	}

   270

}

   271

   272

static const Widget _graph_legend_widgets[] = {

   273

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

   274

{    WWT_CAPTION,   RESIZE_NONE,    14,    11,   249,     0,    13, STR_704E_KEY_TO_COMPANY_GRAPHS, STR_018C_WINDOW_TITLE_DRAG_THIS},

   275

{      WWT_PANEL,   RESIZE_NONE,    14,     0,   249,    14,   113, 0x0,                            STR_NULL},

   276

{      WWT_PANEL,   RESIZE_NONE,    14,     2,   247,    16,    27, 0x0,                            STR_704F_CLICK_HERE_TO_TOGGLE_COMPANY},

   277

{      WWT_PANEL,   RESIZE_NONE,    14,     2,   247,    28,    39, 0x0,                            STR_704F_CLICK_HERE_TO_TOGGLE_COMPANY},

   278

{      WWT_PANEL,   RESIZE_NONE,    14,     2,   247,    40,    51, 0x0,                            STR_704F_CLICK_HERE_TO_TOGGLE_COMPANY},

   279

{      WWT_PANEL,   RESIZE_NONE,    14,     2,   247,    52,    63, 0x0,                            STR_704F_CLICK_HERE_TO_TOGGLE_COMPANY},

   280

{      WWT_PANEL,   RESIZE_NONE,    14,     2,   247,    64,    75, 0x0,                            STR_704F_CLICK_HERE_TO_TOGGLE_COMPANY},

   281

{      WWT_PANEL,   RESIZE_NONE,    14,     2,   247,    76,    87, 0x0,                            STR_704F_CLICK_HERE_TO_TOGGLE_COMPANY},

   282

{      WWT_PANEL,   RESIZE_NONE,    14,     2,   247,    88,    99, 0x0,                            STR_704F_CLICK_HERE_TO_TOGGLE_COMPANY},

   283

{      WWT_PANEL,   RESIZE_NONE,    14,     2,   247,   100,   111, 0x0,                            STR_704F_CLICK_HERE_TO_TOGGLE_COMPANY},

   284

{   WIDGETS_END},

   285

};

   286

   287

static const WindowDesc _graph_legend_desc = {

   288

	WDP_AUTO, WDP_AUTO, 250, 114,

   289

	WC_GRAPH_LEGEND,0,

   290

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET,

   291

	_graph_legend_widgets,

   292

	GraphLegendWndProc

   293

};

   294

   295

static void ShowGraphLegend(void)

   296

{

   297

	AllocateWindowDescFront(&_graph_legend_desc, 0);

   298

}

   299

   300

/********************/

   301

/* OPERATING PROFIT */

   302

/********************/

   303

   304

static void SetupGraphDrawerForPlayers(GraphDrawer *gd)

   305

{

   306

	const Player* p;

   307

	uint excludebits = _legend_excludebits;

   308

	int nums;

   309

	int mo,yr;

   310

   311

	// Exclude the players which aren't valid

   312

	FOR_ALL_PLAYERS(p) {

   313

		if (!p->is_active) SETBIT(excludebits,p->index);

   314

	}

   315

	gd->sel = excludebits;

   316

	gd->num_vert_lines = 24;

   317

   318

	nums = 0;

   319

	FOR_ALL_PLAYERS(p) {

   320

		if (p->is_active) nums = max(nums,p->num_valid_stat_ent);

   321

	}

   322

	gd->num_on_x_axis = min(nums,24);

   323

   324

	mo = (_cur_month/3-nums)*3;

   325

	yr = _cur_year;

   326

	while (mo < 0) {

   327

		yr--;

   328

		mo += 12;

   329

	}

   330

   331

	gd->year = yr;

   332

	gd->month = mo;

   333

}

   334

   335

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

   336

{

   337

	switch (e->event) {

   338

	case WE_PAINT: {

   339

		GraphDrawer gd;

   340

		const Player* p;

   341

		int i,j;

   342

		int numd;

   343

   344

		DrawWindowWidgets(w);

   345

   346

		gd.left = 2;

   347

		gd.top = 18;

   348

		gd.height = 136;

   349

		gd.include_neg = true;

   350

		gd.format_str_y_axis = STR_CURRCOMPACT;

   351

		gd.color_3 = 0x10;

   352

		gd.color_2 = 0xD7;

   353

		gd.bg_line_color = 0xE;

   354

   355

		SetupGraphDrawerForPlayers(&gd);

   356

   357

		numd = 0;

   358

		FOR_ALL_PLAYERS(p) {

   359

			if (p->is_active) {

   360

				gd.colors[numd] = _colour_gradient[p->player_color][6];

   361

				for (j = gd.num_on_x_axis, i = 0; --j >= 0;) {

   362

					gd.cost[numd][i] = (j >= p->num_valid_stat_ent) ? INVALID_VALUE : (uint64)(p->old_economy[j].income + p->old_economy[j].expenses);

   363

					i++;

   364

				}

   365

			}

   366

			numd++;

   367

		}

   368

   369

		gd.num_dataset = numd;

   370

   371

		DrawGraph(&gd);

   372

	}	break;

   373

	case WE_CLICK:

   374

		if (e->we.click.widget == 2) /* Clicked on Legend */

   375

			ShowGraphLegend();

   376

		break;

   377

	}

   378

}

   379

   380

static const Widget _operating_profit_widgets[] = {

   381

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

   382

{    WWT_CAPTION,   RESIZE_NONE,    14,    11,   525,     0,    13, STR_7025_OPERATING_PROFIT_GRAPH, STR_018C_WINDOW_TITLE_DRAG_THIS},

   383

{ WWT_PUSHTXTBTN,   RESIZE_NONE,    14,   526,   575,     0,    13, STR_704C_KEY,                    STR_704D_SHOW_KEY_TO_GRAPHS},

   384

{      WWT_PANEL,   RESIZE_NONE,    14,     0,   575,    14,   173, 0x0,                             STR_NULL},

   385

{   WIDGETS_END},

   386

};

   387

   388

static const WindowDesc _operating_profit_desc = {

   389

	WDP_AUTO, WDP_AUTO, 576, 174,

   390

	WC_OPERATING_PROFIT,0,

   391

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS,

   392

	_operating_profit_widgets,

   393

	OperatingProfitWndProc

   394

};

   395

   396

   397

void ShowOperatingProfitGraph(void)

   398

{

   399

	if (AllocateWindowDescFront(&_operating_profit_desc, 0)) {

   400

		InvalidateWindow(WC_GRAPH_LEGEND, 0);

   401

	}

   402

}

   403

   404

   405

/****************/

   406

/* INCOME GRAPH */

   407

/****************/

   408

   409

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

   410

{

   411

	switch (e->event) {

   412

	case WE_PAINT: {

   413

		GraphDrawer gd;

   414

		const Player* p;

   415

		int i,j;

   416

		int numd;

   417

   418

		DrawWindowWidgets(w);

   419

   420

		gd.left = 2;

   421

		gd.top = 18;

   422

		gd.height = 104;

   423

		gd.include_neg = false;

   424

		gd.format_str_y_axis = STR_CURRCOMPACT;

   425

		gd.color_3 = 0x10;

   426

		gd.color_2 = 0xD7;

   427

		gd.bg_line_color = 0xE;

   428

		SetupGraphDrawerForPlayers(&gd);

   429

   430

		numd = 0;

   431

		FOR_ALL_PLAYERS(p) {

   432

			if (p->is_active) {

   433

				gd.colors[numd] = _colour_gradient[p->player_color][6];

   434

				for (j = gd.num_on_x_axis, i = 0; --j >= 0;) {

   435

					gd.cost[numd][i] = (j >= p->num_valid_stat_ent) ? INVALID_VALUE : (uint64)p->old_economy[j].income;

   436

					i++;

   437

				}

   438

			}

   439

			numd++;

   440

		}

   441

   442

		gd.num_dataset = numd;

   443

   444

		DrawGraph(&gd);

   445

		break;

   446

	}

   447

   448

	case WE_CLICK:

   449

		if (e->we.click.widget == 2)

   450

			ShowGraphLegend();

   451

		break;

   452

	}

   453

}

   454

   455

static const Widget _income_graph_widgets[] = {

   456

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

   457

{    WWT_CAPTION,   RESIZE_NONE,    14,    11,   525,     0,    13, STR_7022_INCOME_GRAPH, STR_018C_WINDOW_TITLE_DRAG_THIS},

   458

{ WWT_PUSHTXTBTN,   RESIZE_NONE,    14,   526,   575,     0,    13, STR_704C_KEY,          STR_704D_SHOW_KEY_TO_GRAPHS},

   459

{      WWT_PANEL,   RESIZE_NONE,    14,     0,   575,    14,   141, 0x0,                   STR_NULL},

   460

{   WIDGETS_END},

   461

};

   462

   463

static const WindowDesc _income_graph_desc = {

   464

	WDP_AUTO, WDP_AUTO, 576, 142,

   465

	WC_INCOME_GRAPH,0,

   466

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS,

   467

	_income_graph_widgets,

   468

	IncomeGraphWndProc

   469

};

   470

   471

void ShowIncomeGraph(void)

   472

{

   473

	if (AllocateWindowDescFront(&_income_graph_desc, 0)) {

   474

		InvalidateWindow(WC_GRAPH_LEGEND, 0);

   475

	}

   476

}

   477

   478

/*******************/

   479

/* DELIVERED CARGO */

   480

/*******************/

   481

   482

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

   483

{

   484

	switch (e->event) {

   485

	case WE_PAINT: {

   486

		GraphDrawer gd;

   487

		const Player* p;

   488

		int i,j;

   489

		int numd;

   490

   491

		DrawWindowWidgets(w);

   492

   493

		gd.left = 2;

   494

		gd.top = 18;

   495

		gd.height = 104;

   496

		gd.include_neg = false;

   497

		gd.format_str_y_axis = STR_7024;

   498

		gd.color_3 = 0x10;

   499

		gd.color_2 = 0xD7;

   500

		gd.bg_line_color = 0xE;

   501

		SetupGraphDrawerForPlayers(&gd);

   502

   503

		numd = 0;

   504

		FOR_ALL_PLAYERS(p) {

   505

			if (p->is_active) {

   506

				gd.colors[numd] = _colour_gradient[p->player_color][6];